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( )