コード例 #1
0
  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)))
コード例 #2
0
 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')
コード例 #3
0
  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()
コード例 #4
0
 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')
コード例 #5
0
  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')
コード例 #6
0
  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')))
コード例 #7
0
    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)
コード例 #8
0
  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)
コード例 #9
0
  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'}})
コード例 #10
0
  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')
コード例 #11
0
    def testMultipleThreadedConnectionsWithDifferentUsers(self):
        data_exporter = tree_exporter.BindTreeExport(CONFIG_FILE)
        self.daemon_instance.core_die_time = 7200
        roster_client_lib.RunFunction(u'MakeZone',
                                      USERNAME,
                                      credstring=self.credential,
                                      args=['new_zone', 'master', 'zone.com.'],
                                      server_name=self.server_name,
                                      password=PASSWORD)

        cred_dict = {}
        for user_number in range(40):

            roster_client_lib.RunFunction(u'MakeUser',
                                          USERNAME,
                                          credstring=self.credential,
                                          args=['user%s' % user_number, 128],
                                          server_name=self.server_name)
            cred_dict['user%s' %
                      user_number] = roster_client_lib.GetCredentials(
                          'user%s' % user_number,
                          'tost',
                          server_name=self.server_name)

        client_threads = []
        for record_number in range(5):
            for user_number in range(40):
                new_client_thread = ClientRecordModifyThread(
                    'user%s' % user_number,
                    '192.168.%s.%s' % (user_number, record_number),
                    'host%s-%s' % (user_number, record_number),
                    cred_dict['user%s' % user_number], self)
                new_client_thread.daemon = True
                new_client_thread.start()
                client_threads.append(new_client_thread)
            data_exporter.db_instance.StartTransaction()
            try:
                data_exporter.db_instance.LockDb()
                try:
                    data_exporter.GetRawData()
                finally:
                    data_exporter.db_instance.UnlockDb()
            finally:
                data_exporter.db_instance.EndTransaction()

        for old_thread in client_threads:
            old_thread.join()
コード例 #12
0
    def setUp(self):
        self.config_instance = roster_core.Config(file_name=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.core_instance = roster_core.Core(u'sharrell',
                                              self.config_instance)
        self.tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
        self.db_instance = db_instance

        if (os.path.exists(self.tree_exporter_instance.backup_dir)):
            shutil.rmtree(self.tree_exporter_instance.backup_dir)
コード例 #13
0
  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)
コード例 #14
0
    def setUp(self):
        self.config_instance = roster_core.Config(file_name=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.core_instance = roster_core.Core(u'sharrell',
                                              self.config_instance)
        self.db_recovery_instance = db_recovery.Recover(
            u'sharrell', self.config_instance)
        self.tree_exporter_instance = tree_exporter.BindTreeExport(CONFIG_FILE)
        self.db_instance = db_instance

        self.core_instance.RemoveZone(u'eas.university.edu')
        self.core_instance.RemoveZone(u'bio.university.edu')
        self.core_instance.RemoveZone(u'cs.university.edu')
コード例 #15
0
    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')
コード例 #16
0
    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()

        if (not os.path.exists(BINDDIR)):
            os.mkdir(BINDDIR)
        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)

        db_instance = self.config_instance.GetDb()
        db_instance.CreateRosterDatabase()

        self.root_config_dir = os.path.expanduser(
            self.config_instance.config_file['exporter']['root_config_dir'])
        self.backup_dir = os.path.expanduser(
            self.config_instance.config_file['exporter']['backup_dir'])
        self.tree_exporter_instance = tree_exporter.BindTreeExport(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(BINDDIR)):
            os.mkdir(BINDDIR)
        if (not os.path.exists('%s/named/' % BINDDIR.rstrip('/'))):
            os.mkdir('%s/named/' % BINDDIR.rstrip('/'))
        if (not os.path.exists(TESTDIR)):
            os.mkdir(TESTDIR)

        self.core_instance.MakeView(u'test_view')
        self.core_instance.MakeZone(u'forward_zone',
                                    u'master',
                                    u'sub.university.lcl.',
                                    view_name=u'test_view')
        self.core_instance.MakeZone(u'reverse_zone',
                                    u'master',
                                    u'0.168.192.in-addr.arpa.',
                                    view_name=u'test_view')
        self.core_instance.MakeZone(u'reverse_ipv6_zone',
                                    u'master',
                                    u'8.0.e.f.f.3.ip6.arpa.',
                                    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 forward_zone' %
                          (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()
        output = os.popen('python %s -f test_data/test_reverse_zone.db '
                          '--view test_view -u %s --config-file %s '
                          '-z reverse_zone' %
                          (ZONE_IMPORTER_EXEC, USERNAME, CONFIG_FILE))
        self.assertEqual(
            output.read(), 'Loading in test_data/test_reverse_zone.db\n'
            '6 records loaded from zone '
            'test_data/test_reverse_zone.db\n'
            '6 total records added\n')
        output.close()

        output = os.popen('python %s -f test_data/test_reverse_ipv6_zone.db '
                          '--view test_view -u %s --config-file %s '
                          '-z reverse_ipv6_zone' %
                          (ZONE_IMPORTER_EXEC, USERNAME, CONFIG_FILE))
        self.assertEqual(
            output.read(), 'Loading in test_data/test_reverse_ipv6_zone.db\n'
            '5 records loaded from zone '
            'test_data/test_reverse_ipv6_zone.db\n'
            '5 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/rndc.key"; options { pid-file "test_data/named.pid";};\n'\
            'controls { inet 127.0.0.1 port %d allow{localhost;} keys {rndc-key;};};' % (BINDDIR.rstrip('/'), 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
        shutil.copyfile('test_data/named.blank.conf',
                        os.path.join(BINDDIR, 'named.conf'))
        named_file_contents = open(os.path.join(BINDDIR, 'named.conf')).read()
        named_file_contents = named_file_contents.replace(
            'RNDC_KEY', '%s/rndc.key' % BINDDIR.rstrip('/'))
        named_file_contents = named_file_contents.replace(
            'NAMED_DIR', '%s/named/' % BINDDIR.rstrip('/'))
        named_file_contents = named_file_contents.replace(
            'NAMED_PID', '%s/test_data/named.pid' % os.getcwd())
        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, '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 %snamed.conf' %
                               (self.port, SSH_USER, BINDDIR),
                               capture=True)
        time.sleep(2)
コード例 #17
0
    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)
コード例 #18
0
  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'])
コード例 #19
0
  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)