def testTarDnsBindFiles(self):
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
# No DNS tree yet
self.assertRaises(config_lib.ExporterNoFileError, config_lib_instance.TarDnsBindFiles, 'localhost')
tree_exporter_instance.ExportAllBindTrees()
audit_id, filename = config_lib_instance.FindNewestDnsTreeFilename()
config_lib_instance.UnTarDnsTree(audit_id)
# No such DNS server
self.assertRaises(config_lib.ServerCheckError, config_lib_instance.TarDnsBindFiles, 'bad')
# Invalid tree format
f = open('%s/localhost/named/bad.txt' % self.root_config_dir, 'w')
f.close()
self.assertRaises(config_lib.ExporterListFileError, config_lib_instance.TarDnsBindFiles, 'localhost')
os.remove('%s/localhost/named/bad.txt' % self.root_config_dir)
# Success
config_lib_instance.TarDnsBindFiles('localhost')
self.assertTrue(os.path.exists('%s/localhost/localhost.tar.bz2' % self.root_config_dir))
os.mkdir('%s/test/' % self.root_config_dir)
shutil.move('%s/localhost/localhost.tar.bz2' % self.root_config_dir,
'%s/test/localhost.tar.bz2' % self.root_config_dir)
tar_file = tarfile.open('%s/test/localhost.tar.bz2' % self.root_config_dir, 'r:bz2')
tarred_files = tar_file.getnames()
for tarred in tarred_files:
self.assertTrue(os.path.exists('%s/localhost/%s' % (self.root_config_dir, tarred)))
def testTarringSlaveZone(self):
for zone in self.core_instance.ListZones():
self.core_instance.RemoveZone(zone)
self.core_instance.MakeDnsServer(u'server1', u'some_user', u'/bind/dir/',
u'/test/dir/')
self.core_instance.MakeDnsServerSet(u'server_set1')
self.core_instance.MakeDnsServerSetAssignments(u'server1', u'server_set1')
self.core_instance.MakeDnsServerSetViewAssignments(u'external', 1, u'server_set1')
self.core_instance.MakeZone(u'test_zone', u'slave', u'test_zone.',
view_name=u'external', make_any=False)
self.core_instance.MakeNamedConfGlobalOption(u'server_set1', u'recursion no;')
tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
tree_exporter_instance.ExportAllBindTrees()
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
config_lib_instance.UnTarDnsTree()
#Make sure we exported the empty 'external' folder
self.assertTrue(os.path.exists(os.path.join(self.root_config_dir,
'server1/named/external')))
config_lib_instance.TarDnsBindFiles(u'server1')
try:
untarred_path = os.path.join(self.root_config_dir, 'server1_untarred')
tar_file = tarfile.open(
os.path.join(self.root_config_dir, 'server1', 'server1.tar.bz2'),
'r:bz2')
tar_file.extractall(path=untarred_path)
#Make sure we tarred the empty 'external' folder
self.assertTrue(os.path.exists(os.path.join(untarred_path,
'named/external')))
finally:
tar_file.close()
def testGetNamedZoneToolArgs(self):
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
tree_exporter_instance.ExportAllBindTrees()
config_lib_instance.UnTarDnsTree()
self.assertEqual(config_lib_instance.GetNamedZoneToolArgs('localhost', 'external', 'forward_zone.db'),
'-i full-sibling -S warn -W warn -k warn -m warn -r warn -M warn')
def testGetDnsServerInfo(self):
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
tree_exporter_instance.ExportAllBindTrees()
audit_id, filename = config_lib_instance.FindNewestDnsTreeFilename()
config_lib_instance.UnTarDnsTree(audit_id)
# This is temporary until DNS tree exporter is committed, at which it will be unnecessary.
if( os.path.exists('%s/255.254.253.252/named/255.254.253.252_config' % self.root_config_dir) ):
os.remove('%s/255.254.253.252/named/255.254.253.252_config' % self.root_config_dir)
if( os.path.exists('%s/localhost/named/localhost_config' % self.root_config_dir) ):
os.remove('%s/localhost/named/localhost_config' % self.root_config_dir)
# End of needing to remove
# No .info file
#self.assertRaises(config_lib.ServerCheckError, config_lib_instance.GetDnsServerInfo, 'localhost')
# Invalid .info file
invalid_file = open('%s/localhost/localhost.info' % self.root_config_dir, 'w')
invalid_file.write('[tools]')
invalid_file.close()
self.assertRaises(config_lib.ServerCheckError, config_lib_instance.GetDnsServerInfo, 'localhost')
server1_information = {'server_info': {
'server_name': 'localhost',
'server_user': SSH_USER,
'ssh_host': '%s@localhost:22' % SSH_USER,
'bind_dir': BINDDIR,
'test_dir': TESTDIR,
'bind_version': 'UNKNOWN'},
'tools': {}}
config_lib_instance.WriteDnsServerInfo(server1_information)
server2_information = {'server_info': {
'server_name': '255.254.253.252',
'server_user': SSH_USER,
'ssh_host': '%[email protected]:22' % SSH_USER,
'bind_dir': BINDDIR,
'test_dir': TESTDIR,
'bind_version': 'UNKNOWN'},
'tools': {
'named-compilezone': True,
'named-checkzone': True,
'named-checkconf': False ,
'tar': False}}
config_lib_instance.WriteDnsServerInfo(server2_information)
config_lib_instance.TarDnsTree(audit_id)
# No exported trees
self.assertRaises(config_lib.ExporterNoFileError, config_lib_instance.GetDnsServerInfo, 'localhost')
config_lib_instance.UnTarDnsTree(audit_id)
# Checking for correct read in
self.assertEqual(config_lib_instance.GetDnsServerInfo('localhost'),
server1_information)
self.assertEqual(config_lib_instance.GetDnsServerInfo('255.254.253.252'),
server2_information)
# No existing server
self.assertRaises(config_lib.ServerCheckError, config_lib_instance.GetDnsServerInfo, 'bad_server')
def testUnTarInCorrectLocation(self):
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
tree_exporter_instance.ExportAllBindTrees()
config_lib_instance.UnTarDnsTree()
self.assertTrue(os.path.exists('%s/localhost' % self.root_config_dir))
config_lib_instance.backup_dir = '%s/%s' % (os.getcwd(), config_lib_instance.backup_dir)
config_lib_instance.root_config_dir = 'config_test_dir/config'
os.chdir('test_data')
config_lib_instance.UnTarDnsTree()
os.chdir('../')
self.assertTrue(os.path.exists('test_data/config_test_dir/config/localhost'))
self.assertTrue(os.path.exists('test_data/config_test_dir/config/localhost/named/named.ca'))
shutil.rmtree('test_data/config_test_dir')
config_lib_instance.root_config_dir = '../root_config_dir'
os.chdir('test_data/named')
config_lib_instance.UnTarDnsTree()
os.chdir('../../')
self.assertTrue(os.path.exists('test_data/root_config_dir/localhost'))
shutil.rmtree('test_data/root_config_dir')
config_lib_instance.root_config_dir = '%s/test_data/root_config_dir_abs' % os.getcwd()
config_lib_instance.UnTarDnsTree()
self.assertTrue(os.path.exists('test_data/root_config_dir_abs/localhost'))
shutil.rmtree('test_data/root_config_dir_abs')
def testUnTarDnsTree(self):
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
tree_exporter_instance.ExportAllBindTrees()
self.assertRaises(config_lib.ExporterNoFileError, config_lib_instance.UnTarDnsTree, 96)
config_lib_instance.UnTarDnsTree()
self.assertTrue(os.path.exists('%s/%s' % (self.root_config_dir, 'localhost')))
def setUp(self):
self.port = PickUnusedPort()
self.rndc_port = PickUnusedPort()
while (self.rndc_port == self.port):
self.rndc_port = PickUnusedPort()
if (not os.path.exists(BINDDIR)):
os.mkdir(BINDDIR)
if (not os.path.exists(TESTDIR)):
os.mkdir(TESTDIR)
rndc_key = open(RNDC_KEY, 'w')
rndc_key.write(RNDC_KEY_DATA)
rndc_key.close()
rndc_conf = open(RNDC_CONF, 'w')
rndc_conf.write(RNDC_CONF_DATA)
rndc_conf.close()
fabric_api.env.warn_only = True
fabric_state.output['everything'] = False
fabric_state.output['warnings'] = False
fabric_api.env.host_string = "%s@%s" % (SSH_USER, TEST_DNS_SERVER)
self.config_instance = roster_core.Config(file_name=CONFIG_FILE)
self.root_config_dir = self.config_instance.config_file['exporter'][
'root_config_dir'].rstrip('/').lstrip('./')
self.backup_dir = self.config_instance.config_file['exporter'][
'backup_dir'].rstrip('/').lstrip('./')
self.tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
self.lockfile = self.config_instance.config_file['server']['lock_file']
database_server = self.config_instance.config_file['database'][
'server']
traceroute_output = os.popen(
'dig +trace www.google.com | grep Received').read().strip('\n')
traceroute_lines = traceroute_output.split('\n')
self.real_dns_server = traceroute_lines[0].split(' ')[5].split('#')[0]
db_instance = self.config_instance.GetDb()
db_instance.CreateRosterDatabase()
data = open(DATA_FILE, 'r').read()
db_instance.StartTransaction()
db_instance.cursor.execute(data)
db_instance.EndTransaction()
db_instance.close()
self.db_instance = db_instance
self.core_instance = roster_core.Core(u'sharrell',
self.config_instance)
self.core_instance.RemoveZone(u'cs.university.edu')
self.core_instance.RemoveZone(u'bio.university.edu')
self.core_instance.RemoveZone(u'eas.university.edu')
self.config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
if (not os.path.exists(TESTDIR)):
os.system('mkdir %s' % TESTDIR)
def testTarDnsTree(self):
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
tree_exporter_instance.ExportAllBindTrees()
self.assertRaises(config_lib.ExporterAuditIdError, config_lib_instance.TarDnsTree, None)
self.assertRaises(config_lib.ExporterListFileError, config_lib_instance.TarDnsTree, '16')
os.mkdir(self.root_config_dir)
config_lib_instance.UnTarDnsTree('18')
self.assertEqual(config_lib_instance.TarDnsTree('16'), None)
def testErrors(self):
# Running dnsservercheck
command = os.popen('python %s --config-file %s -i 17 -d %s' %
(SERVER_CHECK_EXEC, CONFIG_FILE, TEST_DNS_SERVER))
output = command.read()
command.close()
self.assertEqual(output, '')
# Running dnsconfisync
command = os.popen('python %s -d localhost --config-file %s -i 17 '
'--rndc-key %s --rndc-conf %s --rndc-port %s' %
(CONFIG_SYNC_EXEC, CONFIG_FILE, RNDC_KEY, RNDC_CONF,
self.rndc_port))
output = command.read()
command.close()
self.assertEqual(output, '')
#Messing with the zone files so that dnsquerycheck will not pass
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
config_lib_instance.UnTarDnsTree()
zone_dir = '%s/%s/named/test_view' % (self.root_config_dir.rstrip('/'),
TEST_DNS_SERVER)
for zone_file_name in os.listdir(zone_dir):
zone_file_path = os.path.join(zone_dir, zone_file_name)
zone_file_handle = open(zone_file_path, 'r')
zone_file_string = zone_file_handle.read()
zone_file_string = zone_file_string.replace('.lcl', '.lol')
zone_file_handle.close()
zone_file_handle = open(zone_file_path, 'w')
zone_file_handle.write(zone_file_string)
zone_file_handle.close()
config_lib_instance.TarDnsTree(17)
# Running dnsquerycheck
command = os.popen(
'python %s -d %s -c %s -p %s -i 17' %
(QUERY_CHECK_EXEC, TEST_DNS_SERVER, CONFIG_FILE, self.port))
output = command.read()
command.close()
self.assertEqual(
output, 'Zone reverse_ipv6_zone does not appear to be online.\n'
'Zone reverse_zone does not appear to be online.\n'
'Zone forward_zone does not appear to be online.\n')
command = os.popen('python %s -d %s -p %s -f no_file' %
(QUERY_CHECK_EXEC, TEST_DNS_SERVER, self.port))
output = command.read()
command.close()
self.assertEqual(output, 'ERROR: Unable to open zone file no_file\n')
def testGetZoneList(self):
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
self.assertRaises(config_lib.ServerCheckError, config_lib_instance.GetZoneList, 'bad')
tree_exporter_instance.ExportAllBindTrees()
config_lib_instance.UnTarDnsTree()
f = open('%s/localhost/named/external/local.db' % self.root_config_dir, 'wb')
f.close()
self.assertRaises(errors.FunctionError, config_lib_instance.GetZoneList, 'localhost')
os.remove('%s/localhost/named/external/local.db' % self.root_config_dir)
self.assertEqual(config_lib_instance.GetZoneList('localhost'), {'external':{'university.lcl':'forward_zone.db'}})
def testChangeNamedDirectory(self):
self.assertEqual(self.core_instance.ListRecords(), [])
command = os.popen('python %s -f test_data/test_zone.db '
'--view test_view -u %s --config-file %s '
'-z sub.university.lcl' %
(ZONE_IMPORTER_EXEC, USERNAME, CONFIG_FILE))
self.assertEqual(
command.read(), 'Loading in test_data/test_zone.db\n'
'17 records loaded from zone test_data/test_zone.db\n'
'17 total records added\n')
command.close()
self.core_instance.MakeDnsServer(DNS_SERVER, SSH_USER, BIND_DIR,
TEST_DIR)
self.core_instance.MakeDnsServerSet(u'set1')
self.core_instance.MakeDnsServerSetAssignments(DNS_SERVER, u'set1')
self.core_instance.MakeDnsServerSetViewAssignments(
u'test_view', 1, u'set1')
self.core_instance.MakeNamedConfGlobalOption(u'set1', u'#options')
self.tree_exporter_instance.ExportAllBindTrees()
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
audit_log_id, filename = config_lib_instance.FindNewestDnsTreeFilename(
)
config_lib_instance.UnTarDnsTree(audit_log_id)
named_conf_handle = open(
'%s/%s/named.conf.a' %
(config_lib_instance.root_config_dir, DNS_SERVER), 'r')
named_conf_contents = named_conf_handle.read()
named_conf_handle.close()
options_string = 'options { directory "%snamed"; };' % BIND_DIR
new_options_string = 'options { \ndirectory "%snamed";\n};' % BIND_DIR
self.assertTrue(options_string in named_conf_contents)
named_conf_contents = named_conf_contents.replace(
options_string, new_options_string, 1)
self.assertTrue(new_options_string in named_conf_contents)
named_conf_handle = open(
'%s/%s/named.conf.a' %
(config_lib_instance.root_config_dir, DNS_SERVER), 'w')
named_conf_handle.write(named_conf_contents)
named_conf_handle.close()
config_lib_instance.TarDnsTree(audit_log_id)
command = os.popen('python %s --config-file %s' % (EXEC, CONFIG_FILE))
time.sleep(2) # Wait for disk to settle
self.assertEqual(command.read(), '')
command.close()
def setUp(self):
self.config_instance = roster_core.Config(file_name=CONFIG_FILE)
self.config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
self.root_config_dir = self.config_instance.config_file['exporter'][
'root_config_dir'].lstrip('./').rstrip('/')
self.backup_dir = self.config_instance.config_file['exporter'][
'backup_dir'].lstrip('./').rstrip('/')
self.bind_config_dir = os.path.expanduser(self.root_config_dir)
self.lockfile = self.config_instance.config_file['server']['lock_file']
self.tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
self.config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
db_instance = self.config_instance.GetDb()
db_instance.CreateRosterDatabase()
data = open(DATA_FILE, 'r').read()
db_instance.StartTransaction()
db_instance.cursor.execute(data)
db_instance.EndTransaction()
db_instance.close()
self.db_instance = db_instance
if (not os.path.exists(TEST_DIR)):
os.system('mkdir %s' % TEST_DIR)
self.core_instance = roster_core.Core(USERNAME, self.config_instance)
self.core_instance.RemoveZone(u'cs.university.edu')
self.core_instance.RemoveZone(u'bio.university.edu')
self.core_instance.RemoveZone(u'eas.university.edu')
self.core_instance.MakeView(u'test_view')
self.core_instance.MakeZone(u'sub.university.lcl',
u'master',
u'sub.university.lcl.',
view_name=u'test_view')
def testFindDnsTreeFilename(self):
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
tree_exporter_instance.ExportAllBindTrees()
file_name = 'dns_tree_%s-18.tar.bz2' % datetime.datetime.now().strftime('%d_%m_%yT%H_%M')
self.assertEqual(config_lib_instance.FindDnsTreeFilename('18'), file_name)
self.assertRaises(config_lib.ExporterAuditIdError, config_lib_instance.FindDnsTreeFilename, None)
config_lib_instance.backup_dir = '/bad/dir/'
self.assertRaises(config_lib.ExporterFileError, config_lib_instance.FindDnsTreeFilename, '16')
config_lib_instance.backup_dir = self.backup_dir
self.assertEqual(config_lib_instance.FindDnsTreeFilename('16'), None)
os.rename('%s/%s' % (self.backup_dir, file_name),
'%s/dns_tree_fail_file.tar.bz2' % self.backup_dir)
self.assertRaises(config_lib.ExporterFileError, config_lib_instance.FindDnsTreeFilename, '16')
def testGenerateAdditionalNamedCheckzoneArgs(self):
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
merged_options_dict = {'check-integrity': 'yes',
'check-siblings': 'yes',
'check-srv-cname': 'warn',
'check-wildcard': 'yes',
'check-names': 'warn',
'check-mx': 'warn',
'check-dup-records': 'warn',
'check-mx-cname': 'warn'}
self.assertEqual(config_lib_instance.GenerateAdditionalNamedCheckzoneArgs(merged_options_dict),
['-i', 'full-sibling',
'-S', 'warn',
'-W', 'warn',
'-k', 'warn',
'-m', 'warn',
'-r', 'warn',
'-M', 'warn'])
def testMergeOptionsDicts(self):
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
global_options_dict = {'directory': '"/home/cookie/Dropbox/Roster/compilezone/trunk/test/test_data/named/named"',
'pid-file': '"test_data/named.pid"'}
view_dict = {'zone "."':
{'type': 'hint', 'file': '"named.ca"'},
'zone "university.lcl"':
{'type': 'master', 'file': '"external/forward_zone.db"'},
'match-clients': {'internal': True}}
zone_dict = {'type': 'master', 'file': '"external/forward_zone.db"'}
self.assertEqual(config_lib_instance.MergeOptionsDicts(global_options_dict, view_dict, zone_dict),
{'check-integrity': 'yes',
'check-siblings': 'yes',
'check-srv-cname': 'warn',
'check-wildcard': 'yes',
'check-names': 'warn',
'check-mx': 'warn',
'check-dup-records': 'warn',
'check-mx-cname': 'warn'})
def testFindNewestDnsTreeFilename(self):
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
os.mkdir(self.backup_dir)
self.assertRaises(config_lib.ExporterNoFileError, config_lib_instance.FindNewestDnsTreeFilename)
tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
tree_exporter_instance.ExportAllBindTrees()
file_name = 'dns_tree_%s-18.tar.bz2' % datetime.datetime.now().strftime('%d_%m_%yT%H_%M')
audit_id, filename = config_lib_instance.FindNewestDnsTreeFilename()
self.assertEqual(filename, file_name)
self.assertEqual(audit_id, 18)
os.rename('%s/%s' % (self.backup_dir, file_name),
'%s/dns_tree_fail.tar.bz2' % self.backup_dir)
self.assertRaises(config_lib.ExporterFileNameError, config_lib_instance.FindNewestDnsTreeFilename)
os.remove('%s/dns_tree_fail.tar.bz2' % self.backup_dir)
self.assertRaises(config_lib.ExporterNoFileError, config_lib_instance.FindNewestDnsTreeFilename)
config_lib_instance.backup_dir = '/bad/directory'
self.assertRaises(config_lib.ExporterListFileError, config_lib_instance.FindNewestDnsTreeFilename)
def __init__(self, config_file_name):
"""Sets self.db_instance
Inputs:
config_file_name: name of config file to load db info from
"""
self.tar_file_name = ''
config_instance = config.Config(file_name=config_file_name)
self.db_instance = config_instance.GetDb()
self.config_lib_instance = config_lib.ConfigLib(config_file_name)
self.raw_data = {}
self.cooked_data = {}
self.root_config_dir = config_instance.config_file['exporter'][
'root_config_dir']
self.backup_dir = os.path.abspath(
os.path.expanduser(
config_instance.config_file['exporter']['backup_dir']))
self.root_hint_file = os.path.abspath(
os.path.expanduser(
config_instance.config_file['exporter']['root_hint_file']))
self.log_instance = audit_log.AuditLog(log_to_syslog=True,
log_to_db=True,
db_instance=self.db_instance)
def testMultipleDnsServers(self):
for zone in self.core_instance.ListZones():
self.core_instance.RemoveZone(zone)
self.core_instance.MakeDnsServer(u'server_1', SSH_USER, BIND_DIR,
TEST_DIR)
self.core_instance.MakeDnsServer(u'server_2', SSH_USER, BIND_DIR,
TEST_DIR)
self.core_instance.MakeDnsServerSet(u'set_1')
self.core_instance.MakeDnsServerSet(u'set_2')
self.core_instance.MakeDnsServerSetAssignments(u'server_1', u'set_1')
self.core_instance.MakeDnsServerSetAssignments(u'server_2', u'set_2')
self.core_instance.MakeView(u'test_view1')
self.core_instance.MakeView(u'test_view2')
self.core_instance.MakeDnsServerSetViewAssignments(
u'test_view1', 1, u'set_1')
self.core_instance.MakeDnsServerSetViewAssignments(
u'test_view2', 1, u'set_2')
self.core_instance.MakeNamedConfGlobalOption(u'set_1', u'#options')
self.core_instance.MakeNamedConfGlobalOption(u'set_2', u'#options')
self.core_instance.MakeZone(u'test_zone1',
u'master',
u'test_zone1.',
view_name=u'test_view1')
self.core_instance.MakeZone(u'test_zone2',
u'master',
u'test_zone2.',
view_name=u'test_view2')
self.assertEqual(self.core_instance.ListRecords(), [])
command = os.popen('python %s -f test_data/test_zone.db '
'--view test_view1 -u %s --config-file %s '
'-z test_zone1' %
(ZONE_IMPORTER_EXEC, USERNAME, CONFIG_FILE))
self.assertEqual(
command.read(), 'Loading in test_data/test_zone.db\n'
'17 records loaded from zone test_data/test_zone.db\n'
'17 total records added\n')
command.close()
command = os.popen('python %s -f test_data/test_zone.db '
'--view test_view2 -u %s --config-file %s '
'-z test_zone2' %
(ZONE_IMPORTER_EXEC, USERNAME, CONFIG_FILE))
self.assertEqual(
command.read(), 'Loading in test_data/test_zone.db\n'
'17 records loaded from zone test_data/test_zone.db\n'
'17 total records added\n')
command.close()
self.tree_exporter_instance.ExportAllBindTrees()
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
audit_log_id, filename = config_lib_instance.FindNewestDnsTreeFilename(
)
command = os.popen('python %s --config-file %s' % (EXEC, CONFIG_FILE))
time.sleep(2) # Wait for disk to settle
self.assertEqual(command.read(), '')
command.close()
self.TarReplaceString(os.path.join('test_data/backup_dir',
filename), u'server_1/named.conf.a',
'type master;', 'type bad1;')
command = os.popen('python %s --config-file %s' % (EXEC, CONFIG_FILE))
time.sleep(2) # Wait for disk to settle
self.assertEqual(
command.read(),
"ERROR: root_config_dir/server_1/named.conf.a:12: 'bad1' unexpected\n"
)
command.close()
self.TarReplaceString(os.path.join('test_data/backup_dir',
filename), u'server_1/named.conf.a',
'type bad1;', 'type master;')
self.TarReplaceString(os.path.join('test_data/backup_dir',
filename), u'server_2/named.conf.a',
'type master;', 'type bad2;')
command = os.popen('python %s --config-file %s' % (EXEC, CONFIG_FILE))
time.sleep(2) # Wait for disk to settle
self.assertEqual(
command.read(),
"ERROR: root_config_dir/server_2/named.conf.a:12: 'bad2' unexpected\n"
)
command.close()
self.TarReplaceString(os.path.join('test_data/backup_dir',
filename), u'server_2/named.conf.a',
'type bad2;', 'type master;')
self.TarReplaceString(os.path.join('test_data/backup_dir', filename),
u'server_1/named/test_view1/test_zone1.db',
'cname', 'bname')
self.TarReplaceString(os.path.join('test_data/backup_dir', filename),
u'server_2/named/test_view2/test_zone2.db',
'cname', 'bname')
command = os.popen('python %s --config-file %s' % (EXEC, CONFIG_FILE))
time.sleep(2) # Wait for disk to settle
output = command.read()
command.close()
self.assertTrue(
"root_config_dir/server_1/named/test_view1/test_zone1.db:18: unknown RR type 'bname'"
in output)
self.assertTrue(
'zone test_zone1/IN: not loaded due to errors.' in output)
self.TarReplaceString(os.path.join('test_data/backup_dir', filename),
u'server_1/named/test_view1/test_zone1.db',
'bname', 'cname')
command = os.popen('python %s --config-file %s' % (EXEC, CONFIG_FILE))
time.sleep(2) # Wait for disk to settle
output = command.read()
self.assertTrue(
"root_config_dir/server_2/named/test_view2/test_zone2.db:18: unknown RR type 'bname'"
in output)
self.assertTrue(
'zone test_zone2/IN: not loaded due to errors.' in output)
command.close()
def setUp(self):
self.config_instance = roster_core.Config(CONFIG_FILE)
self.config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
self.root_config_dir = self.config_instance.config_file['exporter'][
'root_config_dir'].rstrip('/')
self.root_backup_dir = self.config_instance.config_file['exporter'][
'backup_dir'].rstrip('/')
if (os.path.exists(self.root_backup_dir)):
shutil.rmtree(self.root_backup_dir)
os.mkdir(self.root_backup_dir)
if (os.path.exists(self.root_config_dir)):
shutil.rmtree(self.root_config_dir)
os.mkdir(self.root_config_dir)
self.db_instance = self.config_instance.GetDb()
self.db_instance.CreateRosterDatabase()
self.data = open(DATA_FILE, 'r').read()
self.db_instance.StartTransaction()
self.db_instance.cursor.execute(self.data)
self.db_instance.EndTransaction()
self.db_instance.close()
self.core_instance = roster_core.Core(USERNAME, self.config_instance)
self.tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
self.core_instance.RemoveZone(u'cs.university.edu')
self.core_instance.RemoveZone(u'bio.university.edu')
self.core_instance.RemoveZone(u'eas.university.edu')
self.core_instance.MakeDnsServerSet(u'set1')
self.core_instance.MakeView(u'test_view')
self.core_instance.MakeDnsServerSetViewAssignments(
u'test_view', 1, u'set1')
self.core_instance.MakeNamedConfGlobalOption(
u'set1',
u'include "%s/test_data/rndc.key"; options { pid-file "test_data/named.pid";};\n'
'controls { inet 127.0.0.1 port 5555 allow{localhost;} keys {rndc-key;};};'
% (os.getcwd())) # So we can test
self.core_instance.MakeACL(u'test_acl', u'127.0.0.1')
self.core_instance.MakeViewToACLAssignments(u'test_view', u'set1',
u'test_acl', 1)
self.core_instance.MakeZone(u'sub.university.lcl',
u'master',
u'sub.university.lcl.',
view_name=u'test_view')
soa_args_dict = self.core_instance.GetEmptyRecordArgsDict(u'soa')
soa_args_dict[u'refresh_seconds'] = 500
soa_args_dict[u'expiry_seconds'] = 500
soa_args_dict[u'name_server'] = u'ns.sub.university.lcl.'
soa_args_dict[u'minimum_seconds'] = 500
soa_args_dict[u'retry_seconds'] = 500
soa_args_dict[u'serial_number'] = 1000
soa_args_dict[u'admin_email'] = u'root.sub.university.lcl.'
self.core_instance.MakeRecord(u'soa',
u'@',
u'sub.university.lcl',
soa_args_dict,
view_name=u'test_view')
if (not os.path.exists(TESTDIR)):
os.system('mkdir %s' % TESTDIR)
def testWriteDnsServerInfo(self):
server_information = {'server_info': {
'server_name': 'localhost',
'server_user': SSH_USER,
'ssh_host':'%s@localhost:22' % SSH_USER,
'bind_dir': BINDDIR,
'test_dir': TESTDIR,
'bind_version': 'UNKNOWN'},
'tools': {}}
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
tree_exporter_instance.ExportAllBindTrees()
audit_id, filename = config_lib_instance.FindNewestDnsTreeFilename()
config_lib_instance.UnTarDnsTree(audit_id)
# This is temporary until DNS tree exporter is committed, at which it will be unnecessary.
if( os.path.exists('%s/255.254.253.252/named/255.254.253.252_config' % self.root_config_dir) ):
os.remove('%s/255.254.253.252/named/255.254.253.252_config' % self.root_config_dir)
if( os.path.exists('%s/localhost/named/localhost_config' % self.root_config_dir) ):
os.remove('%s/localhost/named/localhost_config' % self.root_config_dir)
# End of needing to remove
config_lib_instance.WriteDnsServerInfo(server_information)
self.assertTrue(os.path.exists('%s/localhost/localhost.info' % self.root_config_dir))
server_information = {'server_info': {
'server_name': '255.254.253.252',
'server_user': SSH_USER,
'ssh_host':'%[email protected]:22' % SSH_USER,
'bind_dir': BINDDIR,
'test_dir': TESTDIR,
'bind_version': 'UNKNOWN'},
'tools': {}}
config_lib_instance.WriteDnsServerInfo(server_information)
self.assertTrue(os.path.exists('%s/255.254.253.252/255.254.253.252.info'%self.root_config_dir))
server_file = ConfigParser.SafeConfigParser()
server_file.read('%s/localhost/localhost.info' % self.root_config_dir)
self.assertTrue(server_file.has_section('server_info'))
self.assertTrue(server_file.has_section('tools'))
self.assertTrue(server_file.has_option('server_info', 'ssh_host'))
self.assertTrue(server_file.has_option('server_info', 'bind_dir'))
self.assertTrue(server_file.has_option('server_info', 'test_dir'))
self.assertEqual(len(server_file.options('tools')), 0)
self.assertEqual(server_file.get('server_info', 'ssh_host'), '%s@localhost:22' % SSH_USER)
self.assertEqual(server_file.get('server_info', 'bind_dir'), BINDDIR)
self.assertEqual(server_file.get('server_info', 'test_dir'), TESTDIR)
del(server_file)
server_file = ConfigParser.SafeConfigParser()
server_file.read('%s/255.254.253.252/255.254.253.252.info' % self.root_config_dir)
self.assertTrue(server_file.has_section('server_info'))
self.assertTrue(server_file.has_section('tools'))
self.assertTrue(server_file.has_option('server_info', 'ssh_host'))
self.assertTrue(server_file.has_option('server_info', 'bind_dir'))
self.assertTrue(server_file.has_option('server_info', 'test_dir'))
self.assertEqual(len(server_file.options('tools')), 0)
self.assertEqual(server_file.get('server_info', 'ssh_host'), '%[email protected]:22' % SSH_USER)
self.assertEqual(server_file.get('server_info', 'bind_dir'), BINDDIR)
self.assertEqual(server_file.get('server_info', 'test_dir'), TESTDIR)
# Redo this after finished refactoring dns_server_info dictionary
self.assertRaises(config_lib.ServerCheckError, config_lib_instance.WriteDnsServerInfo, {})
self.assertRaises(config_lib.ServerCheckError, config_lib_instance.WriteDnsServerInfo, {'server_info':
{'server_name':'bad_server','server_user':'******', 'bind_dir':'/dir','test_dir':'/dir/test', 'bind_version':'UNKNOWN'}})
config_lib_instance.TarDnsTree(audit_id)
self.assertRaises(config_lib.ExporterNoFileError, config_lib_instance.WriteDnsServerInfo, server_information)
config_lib_instance.UnTarDnsTree(audit_id)
server_information = {'server_info': {
'server_name': 'localhost',
'server_user': SSH_USER,
'ssh_host':'%s@localhost:22' % SSH_USER,
'bind_dir': '/some/bind/',
'test_dir': TESTDIR,
'bind_version': 'UNKNOWN'},
'tools': {
'named-compilezone': True,
'named-checkzone': True,
'named-checkconf': True,
'tar': True}}
config_lib_instance.WriteDnsServerInfo(server_information)
self.assertEqual(config_lib_instance.GetDnsServerInfo('localhost'), server_information)
def testCheckDnsServer(self):
# This does not test the raise ServerCheckError: Unable to run 'named'
# since we would have to run a controlled server that does not have
# named installed.
config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
tree_exporter_instance.ExportAllBindTrees()
# ExporterFileError: Can not list files in root dir
if( os.path.exists(self.root_config_dir) ):
shutil.rmtree(self.root_config_dir)
self.assertRaises(config_lib.ExporterFileError,
config_lib_instance.CheckDnsServer, 'localhost', [])
# ServerCheckError: DNS server doesn't exist
config_lib_instance.UnTarDnsTree()
self.assertRaises(config_lib.ServerCheckError, config_lib_instance.CheckDnsServer,
'junk', [])
########################33
# Once tree exporter if complete, this will be removed
########################33
# This is temporary until DNS tree exporter is committed, at which it will be unnecessary.
if( os.path.exists('%s/255.254.253.252/named/255.254.253.252_config' % self.root_config_dir) ):
os.remove('%s/255.254.253.252/named/255.254.253.252_config' % self.root_config_dir)
if( os.path.exists('%s/localhost/named/localhost_config' % self.root_config_dir) ):
os.remove('%s/localhost/named/localhost_config' % self.root_config_dir)
# End of needing to remove
server_info1 = {'server_info':{
'server_name': 'localhost',
'server_user': SSH_USER,
'bind_dir': BINDDIR,
'test_dir': TESTDIR,
'bind_version': 'UNKNOWN'}}
server_info2 = {'server_info':{
'server_name': '255.254.253.252',
'server_user': SSH_USER,
'bind_dir': BINDDIR,
'test_dir': TESTDIR,
'bind_version': 'UNKNOWN'}}
config_lib_instance.WriteDnsServerInfo(server_info1)
config_lib_instance.WriteDnsServerInfo(server_info2)
########################33
########################33
########################33
# ServerCheckError: Metadata file incorrectly written/DNE
shutil.move('%s/localhost/localhost.info' % self.root_config_dir,
'%s/localhost/localhost_bad.info' % self.root_config_dir)
self.assertRaises(config_lib.ServerCheckError, config_lib_instance.CheckDnsServer,
'localhost', [])
shutil.move('%s/localhost/localhost_bad.info' % self.root_config_dir,
'%s/localhost/localhost.info' % self.root_config_dir)
# ServerCheckError: Can not connect via SSH
self.assertRaises(config_lib.ServerCheckError, config_lib_instance.CheckDnsServer,
'255.254.253.252', [])
# ServerCheckError: Remote BIND directory doesn't exist
self.core_instance.UpdateDnsServer(u'localhost', u'localhost', SSH_USER,
u'/junk/', u'/junk/test/')
tree_exporter_instance.ExportAllBindTrees()
config_lib_instance.UnTarDnsTree()
self.assertRaises(config_lib.ServerCheckError, config_lib_instance.CheckDnsServer,
'localhost', [])
# ServerCheckError: Remote test directory doesn't exist
self.core_instance.UpdateDnsServer(u'localhost', u'localhost', SSH_USER,
BINDDIR, u'/junk/test/')
tree_exporter_instance.ExportAllBindTrees()
config_lib_instance.UnTarDnsTree()
self.assertRaises(config_lib.ServerCheckError, config_lib_instance.CheckDnsServer,
'localhost', [])
# Everything Passes
self.core_instance.UpdateDnsServer(u'localhost', u'localhost', SSH_USER,
BINDDIR, TESTDIR)
tree_exporter_instance.ExportAllBindTrees()
config_lib_instance.UnTarDnsTree()
########################33
# Once tree exporter if complete, this will be removed
########################33
# This is temporary until DNS tree exporter is committed, at which it will be unnecessary.
if( os.path.exists('%s/255.254.253.252/named/255.254.253.252_config' % self.root_config_dir) ):
os.remove('%s/255.254.253.252/named/255.254.253.252_config' % self.root_config_dir)
if( os.path.exists('%s/localhost/named/localhost_config' % self.root_config_dir) ):
os.remove('%s/localhost/named/localhost_config' % self.root_config_dir)
# End of needing to remove
server_info1 = {'server_info':{
'server_name': 'localhost',
'server_user': SSH_USER,
'bind_dir': BINDDIR,
'test_dir': TESTDIR,
'bind_version': 'UNKNOWN'}}
server_info2 = {'server_info':{
'server_name': '255.254.253.252',
'server_user': SSH_USER,
'bind_dir': BINDDIR,
'test_dir': TESTDIR,
'bind_version': 'UNKNOWN'}}
config_lib_instance.WriteDnsServerInfo(server_info1)
config_lib_instance.WriteDnsServerInfo(server_info2)
########################33
########################33
########################33
self.assertEqual(config_lib_instance.CheckDnsServer(
'localhost', ['named-checkzone', 'named-checkconf', 'named-compilezone', 'tar']), None)
# Check that info file has additional information
localhost_info = ConfigParser.SafeConfigParser()
localhost_info.read('%s/localhost/localhost.info' % self.root_config_dir)
self.assertTrue(localhost_info.has_section('tools'))
self.assertTrue(localhost_info.has_option('tools', 'named-checkzone'))
self.assertTrue(localhost_info.has_option('tools', 'named-checkconf'))
self.assertTrue(localhost_info.has_option('tools', 'named-compilezone'))
self.assertTrue(localhost_info.has_option('tools', 'tar'))
self.assertRaises(errors.FunctionError, config_lib_instance.CheckDnsServer, 'localhost', ['bad_tool'])
def setUp(self):
def PickUnusedPort():
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((TEST_DNS_SERVER, 0))
addr, port = s.getsockname()
s.close()
return port
self.port = PickUnusedPort()
self.rndc_port = PickUnusedPort()
while (self.rndc_port == self.port):
self.rndc_port = PickUnusedPort()
rndc_key = open(RNDC_KEY, 'w')
rndc_key.write(RNDC_KEY_DATA)
rndc_key.close()
rndc_conf = open(RNDC_CONF, 'w')
rndc_conf.write(RNDC_CONF_DATA)
rndc_conf.close()
fabric_api.env.warn_only = True
fabric_state.output['everything'] = False
fabric_state.output['warnings'] = False
fabric_api.env.host_string = "%s@%s" % (SSH_USER, TEST_DNS_SERVER)
self.config_instance = roster_core.Config(file_name=CONFIG_FILE)
self.root_config_dir = self.config_instance.config_file['exporter'][
'root_config_dir']
self.backup_dir = self.config_instance.config_file['exporter'][
'backup_dir']
db_instance = self.config_instance.GetDb()
db_instance.CreateRosterDatabase()
self.bind_config_dir = os.path.expanduser(
self.config_instance.config_file['exporter']['root_config_dir'])
self.tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
self.config_lib_instance = config_lib.ConfigLib(CONFIG_FILE)
self.lockfile = self.config_instance.config_file['server']['lock_file']
data = open(DATA_FILE, 'r').read()
db_instance.StartTransaction()
db_instance.cursor.execute(data)
db_instance.EndTransaction()
db_instance.close()
self.db_instance = db_instance
self.core_instance = roster_core.Core(USERNAME, self.config_instance)
self.core_instance.RemoveZone(u'cs.university.edu')
self.core_instance.RemoveZone(u'bio.university.edu')
self.core_instance.RemoveZone(u'eas.university.edu')
if (not os.path.exists(TESTDIR)):
os.mkdir(TESTDIR)
if (not os.path.exists(BINDDIR)):
os.mkdir(BINDDIR)
self.core_instance.MakeView(u'test_view')
self.core_instance.MakeZone(u'sub.university.lcl',
u'master',
u'sub.university.lcl.',
view_name=u'test_view')
self.assertEqual(self.core_instance.ListRecords(), [])
output = os.popen('python %s -f test_data/test_zone.db '
'--view test_view -u %s --config-file %s '
'-z sub.university.lcl' %
(ZONE_IMPORTER_EXEC, USERNAME, CONFIG_FILE))
self.assertEqual(
output.read(), 'Loading in test_data/test_zone.db\n'
'17 records loaded from zone test_data/test_zone.db\n'
'17 total records added\n')
output.close()
self.core_instance.MakeDnsServer(TEST_DNS_SERVER, SSH_USER, BINDDIR,
TESTDIR)
self.core_instance.MakeDnsServerSet(u'set1')
self.core_instance.MakeDnsServerSetAssignments(TEST_DNS_SERVER,
u'set1')
self.core_instance.MakeDnsServerSetViewAssignments(
u'test_view', 1, u'set1')
self.core_instance.MakeNamedConfGlobalOption(
u'set1', u'include "%s"; options { pid-file "%s";};\n'
'controls { inet 127.0.0.1 port %d allow{localhost;} '
'keys {rndc-key;};};' %
(RNDC_KEY, os.path.join(
BINDDIR, 'named.pid'), self.rndc_port)) # So we can test
self.core_instance.MakeViewToACLAssignments(u'test_view', u'set1',
u'any', 1)
self.tree_exporter_instance.ExportAllBindTrees()
# Copy blank named.conf to start named with
bind_dir_named_conf = os.path.join(BINDDIR, 'named.conf')
shutil.copyfile('test_data/named.blank.conf', bind_dir_named_conf)
named_file_contents = open(bind_dir_named_conf, 'r').read()
named_file_contents = named_file_contents.replace('RNDC_KEY', RNDC_KEY)
named_file_contents = named_file_contents.replace('NAMED_DIR', BINDDIR)
named_file_contents = named_file_contents.replace(
'NAMED_PID', '%snamed.pid' % BINDDIR)
named_file_contents = named_file_contents.replace(
'RNDC_PORT', str(self.rndc_port))
named_file_contents = named_file_contents.replace(
'SESSION_KEYFILE', '%s/%s' % (os.getcwd(), str(SESSION_KEYFILE)))
named_file_handle = open('%s/named.conf' % BINDDIR.rstrip('/'), 'w')
named_file_handle.write(named_file_contents)
named_file_handle.close()
# Start named
out = fabric_api.local('/usr/sbin/named -p %s -u %s -c %s/named.conf' %
(self.port, SSH_USER, BINDDIR.rstrip('/')),
capture=True)
time.sleep(2)
self.command_string = (
'python %s -d %s --rndc-key %s --rndc-conf %s --rndc-port %s '
'--ssh-id %s --config-file %s ' %
(EXEC, TEST_DNS_SERVER, RNDC_KEY, RNDC_CONF, self.rndc_port,
SSH_ID, CONFIG_FILE))
self.audit_id, filename = self.config_lib_instance.FindNewestDnsTreeFilename(
)
