def testMissingAttribute(self):
        """
        Test the parsing when attributes are missing, should get exceptions
        """
        config_file = get_test_config("siteattributes/siteattributes2.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = siteinformation.SiteInformation(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        mandatory_on_all = ['group']
        # ^ TODO OSG 3.5: add "resource" to this list
        mandatory_on_ce = [
            'host_name', 'sponsor', 'contact', 'email', 'city', 'country',
            'longitude', 'latitude'
        ]
        mandatory = list(mandatory_on_all)
        if ce_installed():
            mandatory += mandatory_on_ce
        for option in mandatory:
            config_file = get_test_config("siteattributes/siteattributes1.ini")
            configuration = ConfigParser.SafeConfigParser()
            configuration.read(config_file)
            configuration.remove_option('Site Information', option)

            settings = siteinformation.SiteInformation(logger=global_logger)
            self.assertRaises(exceptions.SettingError,
                              settings.parse_configuration, configuration)
示例#2
0
    def testBadHost(self):
        """
        Test the check_attributes function when the squid proxy hostname is
        not valie
        """

        if not ce_installed():
            return True
        config_file = get_test_config("squid/squid_bad_host.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = squid.SquidConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        attributes = settings.get_attributes()
        self.assertFalse(settings.check_attributes(attributes),
                         "Did not notice invalid host")

        config_file = get_test_config("squid/squid_bad_host2.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = squid.SquidConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration")

        attributes = settings.get_attributes()
        self.assertFalse(settings.check_attributes(attributes),
                         "Did not notice invalid host")
    def testInvalidLongitude(self):
        """
        Test the check_attributes with invalid longitude values
        """

        config_file = get_test_config("siteattributes/" \
                                      "invalid_longitude1.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = siteinformation.SiteInformation(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        attributes = settings.get_attributes()
        self.assertFalse(settings.check_attributes(attributes),
                         "Invalid latitude ignored")

        config_file = get_test_config("siteattributes/" \
                                      "invalid_longitude2.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)
        settings = siteinformation.SiteInformation(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        attributes = settings.get_attributes()
        self.assertFalse(settings.check_attributes(attributes),
                         "Invalid latitude ignored")
示例#4
0
    def testServiceList(self):
        """
        Test to make sure right services get returned
        """

        config_file = get_test_config("lsf/check_ok.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = lsf.LSFConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)
        services = settings.enabled_services()
        expected_services = {'condor-ce', 'globus-gridftp-server'}
        self.assertEqual(services, expected_services,
                         "List of enabled services incorrect, " +
                         "got %s but expected %s" % (services, expected_services))

        config_file = get_test_config("lsf/lsf_disabled.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = lsf.LSFConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)
        services = settings.enabled_services()
        expected_services = set()
        self.assertEqual(services, expected_services,
                         "List of enabled services incorrect, " +
                         "got %s but expected %s" % (services, expected_services))
    def test_get_option_location(self):
        """
        Test the get option location method in configfile module
        """
        config_directory = get_test_config('config-test1.d')
        location = get_test_config('config-test1.d/00-test.ini')
        opt_location = configfile.get_option_location(
            'first_opt', 'Common', config_directory=config_directory)
        self.assertEqual(
            location, opt_location,
            "Didn't get the correct location for first_opt:" +
            "got %s expected %s" % (opt_location, location))

        location = get_test_config('config-test1.d/10-test.ini')
        opt_location = configfile.get_option_location(
            'second_opt', 'Common', config_directory=config_directory)
        self.assertEqual(
            location, opt_location,
            "Didn't get the correct location for second_opt:" +
            "got %s expected %s" % (opt_location, location))

        location = None
        opt_location = configfile.get_option_location(
            'missing_opt', 'Common', config_directory=config_directory)
        self.assertEqual(
            location, opt_location,
            "Didn't get the correct location for missing_opt:" +
            "got %s expected None" % (opt_location))
示例#6
0
    def testMissingAttribute(self):
        """
        Test the parsing when attributes are missing, should get exceptions
        """

        config_file = get_test_config("rsv/rsv2.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = rsv.RsvConfiguration(logger=global_logger)
        settings.rsv_meta_dir = RSV_META_DIR
        settings.parse_configuration(configuration)

        mandatory = ['enable_nagios']
        for option in mandatory:
            config_file = get_test_config("rsv/rsv1.ini")
            configuration = configparser.SafeConfigParser()
            configuration.read(config_file)
            configuration.remove_option('RSV', option)

            settings = rsv.RsvConfiguration(logger=global_logger)
            settings.rsv_meta_dir = RSV_META_DIR
            self.assertRaises(exceptions.SettingError,
                              settings.parse_configuration,
                              configuration)
示例#7
0
    def test_valid_file(self):
        """
        Test functionality of valid_file function
        """

        filename = get_test_config('utilities/newline.ini')
        _stderr = sys.stderr
        sys.stderr = file(os.devnull, 'wb')
        # need to do this instead of putting this in assert so that stderr can
        # be restored after call
        result = validation.valid_ini_file(filename)
        self.assertFalse(result,
                         "Didn't detect newline in %s" % filename)
        # test whether we catch sections that has a space before the first setting
        filename = get_test_config('utilities/section_space.ini')
        self.assertFalse(result,
                         "Didn't detect space in %s" % filename)
        sys.stderr = _stderr

        filename = get_test_config('utilities/valid_boolean.ini')
        self.assertTrue(validation.valid_ini_file(filename),
                        "Got error on valid file %s" % filename)

        filename = get_test_config('utilities/valid_variable.ini')
        self.assertTrue(validation.valid_ini_file(filename),
                        "Got error on valid file %s" % filename)
示例#8
0
    def test_get_file_list(self):
        """
        Test the list of files that the module things it's reading and the order
        that the files are read in
        """
        config_directory = get_test_config('config-test1.d')
        file_order = [get_test_config('config-test1.d/00-test.ini'),
                      get_test_config('config-test1.d/10-test.ini'),
                      get_test_config('config-test1.d/A-test.ini'),
                      get_test_config('config-test1.d/atest.ini')]
        file_list = configfile.get_file_list(config_directory=config_directory)
        self.assertEqual(file_order,
                         file_list,
                         "Didn't get the files in the correct order: " +
                         " %s\n instead of\n %s" % (file_list, file_order))

        config_directory = get_test_config('config-test2.d')
        file_order = [get_test_config('config-test2.d/00-test.ini'),
                      get_test_config('config-test2.d/10-test.ini'),
                      get_test_config('config-test2.d/A-test.ini'),
                      get_test_config('config-test2.d/atest.ini')]
        file_list = configfile.get_file_list(config_directory=config_directory)
        self.assertEqual(file_order,
                         file_list,
                         "Didn't get the files in the correct order: " +
                         " %s\n instead of\n %s" % (file_list, file_order))
示例#9
0
    def test_get_option_location(self):
        """
        Test the get option location method in configfile module
        """
        config_directory = get_test_config('config-test1.d')
        location = get_test_config('config-test1.d/00-test.ini')
        opt_location = configfile.get_option_location('first_opt',
                                                      'Common',
                                                      config_directory=config_directory)
        self.assertEqual(location,
                         opt_location,
                         "Didn't get the correct location for first_opt:" +
                         "got %s expected %s" % (opt_location, location))

        location = get_test_config('config-test1.d/10-test.ini')
        opt_location = configfile.get_option_location('second_opt',
                                                      'Common',
                                                      config_directory=config_directory)
        self.assertEqual(location,
                         opt_location,
                         "Didn't get the correct location for second_opt:" +
                         "got %s expected %s" % (opt_location, location))

        location = None
        opt_location = configfile.get_option_location('missing_opt',
                                                      'Common',
                                                      config_directory=config_directory)
        self.assertEqual(location,
                         opt_location,
                         "Didn't get the correct location for missing_opt:" +
                         "got %s expected None" % (opt_location))
示例#10
0
    def test_get_file_list(self):
        """
        Test the list of files that the module things it's reading and the order
        that the files are read in
        """
        config_directory = get_test_config('config-test1.d')
        file_order = [
            get_test_config('config-test1.d/00-test.ini'),
            get_test_config('config-test1.d/10-test.ini'),
            get_test_config('config-test1.d/A-test.ini'),
            get_test_config('config-test1.d/atest.ini')
        ]
        file_list = configfile.get_file_list(config_directory=config_directory)
        self.assertEqual(
            file_order, file_list,
            "Didn't get the files in the correct order: " +
            " %s\n instead of\n %s" % (file_list, file_order))

        config_directory = get_test_config('config-test2.d')
        file_order = [
            get_test_config('config-test2.d/00-test.ini'),
            get_test_config('config-test2.d/10-test.ini'),
            get_test_config('config-test2.d/A-test.ini'),
            get_test_config('config-test2.d/atest.ini')
        ]
        file_list = configfile.get_file_list(config_directory=config_directory)
        self.assertEqual(
            file_order, file_list,
            "Didn't get the files in the correct order: " +
            " %s\n instead of\n %s" % (file_list, file_order))
示例#11
0
    def testMissingCondorConfig(self):
        """
        Test the check_attributes function to see if it catches missing
        condor config locations
        """

        for filename in [
                get_test_config("condor/missing_config1.ini"),
                get_test_config("condor/missing_config2.ini")
        ]:
            config_file = os.path.abspath(filename)
            configuration = configparser.SafeConfigParser()
            configuration.read(config_file)

            settings = condor.CondorConfiguration(logger=global_logger)
            try:
                settings.parse_configuration(configuration)
            except Exception as e:
                self.fail(
                    "Received exception while parsing configuration: %s" % e)

            attributes = settings.get_attributes()
            self.assertFalse(
                settings.check_attributes(attributes),
                "Did not notice missing condor config location: " +
                attributes['OSG_CONDOR_CONFIG'])
示例#12
0
 def test_user_check_valid_user(self):
     config_parser = ConfigParser.SafeConfigParser()
     config_file = get_test_config("gip/valid_user.ini")
     config_parser.read(config_file)
     config_parser.set('Install Locations', 'user_vo_map',
                       get_test_config(SAMPLE_VO_MAP_LOCATION))
     gip_config = gip.GipConfiguration(logger=global_logger)
     self.assertTrue(
         gip_config._parse_configuration(config_parser) is None,
         "Flagged valid user as being missing")
示例#13
0
 def test_user_check_valid_user(self):
     config_parser = ConfigParser.SafeConfigParser()
     config_file = get_test_config("gip/valid_user.ini")
     config_parser.read(config_file)
     config_parser.set('Install Locations',
                       'user_vo_map',
                       get_test_config(SAMPLE_VO_MAP_LOCATION))
     gip_config = gip.GipConfiguration(logger=global_logger)
     self.assertTrue(gip_config._parse_configuration(config_parser) is None,
                     "Flagged valid user as being missing")
示例#14
0
    def _test_lcmaps(self, pre_file, post_file, errstring, *update_lcmaps_text_args):
        lcmaps_pre = open(get_test_config(pre_file)).read().strip()
        expected_lcmaps_post = open(get_test_config(post_file)).read().strip()

        settings = misc.MiscConfiguration(logger=global_logger)
        lcmaps_post = settings._update_lcmaps_text(lcmaps_pre, *update_lcmaps_text_args)

        diff = diff_strings(expected_lcmaps_post, lcmaps_post)

        self.assertEqual(diff, '',
                         "%s (diff: \n%s\n)" % (errstring, diff))
示例#15
0
 def test_allowed_vos(self):
     """
     Make sure the allowed VOs is filtered properly.
     """
     config_parser = ConfigParser.SafeConfigParser()
     config_file = get_test_config("gip/allowed_vos.ini")
     config_parser.read(config_file)
     config_parser.set('Install Locations', 'user_vo_map',
                       get_test_config(SAMPLE_VO_MAP_LOCATION))
     gip_config = gip.GipConfiguration(logger=global_logger)
     gip_config._parse_configuration(config_parser)
     gip_config._parse_configuration_ce(config_parser)
示例#16
0
 def test_allowed_vos(self):
     """
     Make sure the allowed VOs is filtered properly.
     """
     config_parser = ConfigParser.SafeConfigParser()
     config_file = get_test_config("gip/allowed_vos.ini")
     config_parser.read(config_file)
     config_parser.set('Install Locations',
                       'user_vo_map',
                       get_test_config(SAMPLE_VO_MAP_LOCATION))
     gip_config = gip.GipConfiguration(logger=global_logger)
     gip_config._parse_configuration(config_parser)
示例#17
0
    def _test_lcmaps(self, pre_file, post_file, errstring,
                     *update_lcmaps_text_args):
        lcmaps_pre = open(get_test_config(pre_file)).read().strip()
        expected_lcmaps_post = open(get_test_config(post_file)).read().strip()

        settings = misc.MiscConfiguration(logger=global_logger)
        lcmaps_post = settings._update_lcmaps_text(lcmaps_pre,
                                                   *update_lcmaps_text_args)

        diff = diff_strings(expected_lcmaps_post, lcmaps_post)

        self.assertEqual(diff, '', "%s (diff: \n%s\n)" % (errstring, diff))
示例#18
0
 def test_user_check_invalid_user(self):
     """
     Check to make sure gip class will distinguish between valid and
     invalid users
     """
     config_parser = ConfigParser.SafeConfigParser()
     config_file = get_test_config("gip/invalid_user.ini")
     config_parser.read(config_file)
     config_parser.set('Install Locations', 'user_vo_map',
                       get_test_config(SAMPLE_VO_MAP_LOCATION))
     gip_config = gip.GipConfiguration(logger=global_logger)
     self.assertRaises(exceptions.SettingError,
                       gip_config._parse_configuration, config_parser)
示例#19
0
    def test_ini_spaces(self):
        """
        Test to make sure ini files with spaces work correctly
        """

        config_dirs = [get_test_config('config-space1.d'),
                       get_test_config('config-space2.d'),
                       get_test_config('config-space3.d')]
        temp = sys.stderr
        sys.stderr = open(os.devnull, 'w')
        for directory in config_dirs:
            self.assertRaises(SystemExit, configfile.read_config_files, config_directory=directory)
        sys.stderr = temp
示例#20
0
    def testParsingMissingITBDefault(self):
        """
        Make sure gratia picks up the itb defaults when the gratia
        section is missing
        """

        # need to be on a CE to get CE defaults
        if not gratia.requirements_are_installed():
            return
        config_file = get_test_config("gratia/itb_default2.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = gratia.GratiaConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        options = settings.options
        variables = {
            'probes': 'jobmanager:gratia-osg-itb.opensciencegrid.org:80'
        }
        for var in variables:
            self.assertTrue(var in options, "Attribute %s missing" % var)
            self.assertEqual(options[var].value,
                             variables[var],
                             "Wrong value obtained for %s, got %s but " \
                             "expected %s" % (var, options[var].value, variables[var]))

        config_file = get_test_config("gratia/itb_default3.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = gratia.GratiaConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        options = settings.options
        variables = {
            'probes': 'jobmanager:gratia-osg-itb.opensciencegrid.org:80'
        }
        for var in variables:
            self.assertTrue(var in options, "Attribute %s missing" % var)
            self.assertEqual(options[var].value,
                             variables[var],
                             "Wrong value obtained for %s, got %s but " \
                             "expected %s" % (var, options[var].value, variables[var]))
示例#21
0
 def test_user_check_invalid_user(self):
     """
     Check to make sure gip class will distinguish between valid and
     invalid users
     """
     config_parser = ConfigParser.SafeConfigParser()
     config_file = get_test_config("gip/invalid_user.ini")
     config_parser.read(config_file)
     config_parser.set('Install Locations',
                       'user_vo_map',
                       get_test_config(SAMPLE_VO_MAP_LOCATION))
     gip_config = gip.GipConfiguration(logger=global_logger)
     self.assertRaises(exceptions.SettingError,
                       gip_config._parse_configuration,
                       config_parser)
示例#22
0
class TestNetwork(unittest.TestCase):
    """
    Unit test class to test NetworkConfiguration class
    """
    def testParsing(self):
        """
        Test misc parsing
        """

        config_file = get_test_config("network/check_blank.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = network.NetworkConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception, e:
            self.fail("Received exception while parsing configuration: %s" % e)
        self.assertTrue(settings.check_attributes({}),
                        "Flagged blank file as invalid")

        config_file = get_test_config("network/check_ok1.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = network.NetworkConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception, e:
            self.fail("Received exception while parsing configuration: %s" % e)
    def testParsing2(self):
        """
        Test siteattributes parsing
        """

        config_file = get_test_config("siteattributes/siteattributes2.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = siteinformation.SiteInformation(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        attributes = settings.get_attributes()
        variables = {'OSG_GROUP': 'OSG',
                     'OSG_HOSTNAME': 'example.com',
                     'OSG_SITE_NAME': 'MY_SITE',
                     'OSG_SPONSOR': 'osg:50 usatlas:50',
                     'OSG_SITE_INFO': 'http://example/com/policy.html',
                     'OSG_CONTACT_NAME': 'Admin Name',
                     'OSG_CONTACT_EMAIL': '*****@*****.**',
                     'OSG_SITE_CITY': 'Chicago',
                     'OSG_SITE_COUNTRY': 'US',
                     'OSG_SITE_LONGITUDE': '-84.23',
                     'OSG_SITE_LATITUDE': '-23.32'}
        for var in variables:
            self.assertTrue(var in attributes,
                            "Attribute %s missing" % var)
            self.assertEqual(attributes[var],
                             variables[var],
                             "Wrong value obtained for %s, got %s but " \
                             "expected %s" % (var, attributes[var], variables[var]))
示例#24
0
    def testOASISConfig(self):
        """
        Test storage parsing when using OASIS configuration
        """

        # StorageConfiguration is not enabled on non-ce installs
        if not utilities.ce_installed():
            return
        config_file = get_test_config("storage/oasis.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = storage.StorageConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        attributes = settings.get_attributes()
        variables = {
            'OSG_STORAGE_ELEMENT': 'False',
            'OSG_DEFAULT_SE': 'test.domain.org',
            'OSG_GRID': '/etc',
            'OSG_APP': '/cvmfs/oasis.opensciencegrid.org',
            'OSG_DATA': 'UNAVAILABLE',
            'OSG_SITE_READ': '/var',
            'OSG_SITE_WRITE': '/usr'
        }
        for var in variables:
            self.assertTrue(var in attributes, "Attribute %s missing" % var)
            self.assertEqual(attributes[var],
                             variables[var],
                             "Wrong value obtained for %s, got %s but " \
                             "expected %s" % (var, attributes[var], variables[var]))
            self.assertTrue(settings.check_attributes(attributes))
示例#25
0
 def test_local_settings(self):
     """
     Test to see if the local settings parsing works.
     """
     config_parser = ConfigParser.SafeConfigParser()
     config_parser.optionxform = str
     config_file = get_test_config("gip/local_settings.ini")
     config_parser.read(config_file)
     local_settings = localsettings.LocalSettings(logger= \
                                                      global_logger)
     local_settings.parse_configuration(config_parser)
     attributes = local_settings.get_attributes()
     self.assertTrue('default' not in attributes,
                     msg="Attributes set that weren't in the test config file")
     self.assertTrue('Foo' in attributes and attributes['Foo'] == 'value1',
                     msg="Incorrectly named key." \
                         "  Desired name: Foo; only found  %s." %
                         (" ".join(attributes.keys())))
     self.assertTrue(attributes['Foo'] == 'value1',
                     msg="Incorrect value wanted value1, " \
                         "got %s" % attributes['Foo'])
     self.assertTrue('bar' in attributes and attributes['bar'] == 'value2',
                     msg="Incorrectly named key." \
                         "  Desired name: bar; only found  %s." %
                         (" ".join(attributes.keys())))
     self.assertTrue('bar' in attributes and attributes['bar'] == 'value2',
                     msg="Incorrect value wanted value2, " \
                         "got %s" % attributes['bar'])
示例#26
0
    def testParsing(self):
        """
        Test configuration parsing
        """

        config_file = get_test_config("sge/sge1.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = sge.SGEConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        attributes = settings.get_attributes()
        options = {
            'OSG_JOB_MANAGER_HOME': './test_files',
            'OSG_SGE_LOCATION': './test_files',
            'OSG_SGE_ROOT': './test_files',
            'OSG_SGE_CELL': 'sge',
            'OSG_JOB_MANAGER': 'SGE'
        }
        for option in options:
            value = options[option]
            self.assertTrue(option in attributes,
                            "Attribute %s missing" % option)
            err_msg = "Wrong value obtained for %s, " \
                      "got %s instead of %s" % (option, attributes[option], value)
            self.assertEqual(attributes[option], value, err_msg)
示例#27
0
    def testParsing(self):
        """
        Test configuration parsing
        """

        config_file = get_test_config("slurm/slurm1.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = slurm.SlurmConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        attributes = settings.get_attributes()
        options = {
            'OSG_JOB_MANAGER_HOME': '/opt/slurm',
            'OSG_PBS_LOCATION': '/opt/slurm',
            'OSG_JOB_MANAGER': 'SLURM'
        }
        for option in options:
            value = options[option]
            self.assertTrue(attributes.has_key(option),
                            "Attribute %s missing" % option)
            err_msg = "Wrong value obtained for %s, " \
                      "got %s instead of %s" % (option, attributes[option], value)
            self.assertEqual(attributes[option], value, err_msg)
示例#28
0
    def testParsing(self):
        """
        Test Gateway module parsing
        """

        config_file = get_test_config("gateway/gateway_default.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = gateway.GatewayConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        options = settings.options
        variables = {
            'gram_gateway_enabled': False,
            'htcondor_gateway_enabled': True
        }
        for var in variables:
            self.assertTrue(options.has_key(var), "Option %s missing" % var)
            self.assertEqual(
                options[var].value, variables[var],
                "Wrong value obtained for %s, got %s but "
                "expected %s" % (var, options[var].value, variables[var]))
示例#29
0
    def testParsing2(self):
        """
        Test misc parsing with negative values
        """

        config_file = get_test_config("misc/misc2.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = misc.MiscConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        options = settings.options
        variables = {
            'gums_host': 'my.gums.org',
            'authorization_method': 'xacml'
        }
        for var in variables:
            self.assertTrue(options.has_key(var), "Option %s missing" % var)
            self.assertEqual(options[var].value,
                             variables[var],
                             "Wrong value obtained for %s, got %s but " \
                             "expected %s" % (var, options[var].value, variables[var]))
示例#30
0
    def testParsingIgnored(self):
        """
        Test parsing when ignored
        """

        config_file = get_test_config("squid/ignored.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = squid.SquidConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        attributes = settings.get_attributes()
        self.assertEqual(len(attributes), 1,
                         "Ignored configuration should have 1 attribute")

        variables = {'OSG_SQUID_LOCATION': 'test.com:3128'}
        for var in variables:
            self.assertTrue(var in attributes,
                            "Attribute %s missing" % var)
            self.assertEqual(attributes[var],
                             variables[var],
                             "Wrong value obtained for %s, got %s but " \
                             "expected %s" % (var, attributes[var], variables[var]))
示例#31
0
    def testParsing(self):
        """
        Test condor parsing
        """

        config_file = get_test_config("condor/condor1.ini")
        configuration = configparser.SafeConfigParser()
        configuration.read(config_file)

        settings = condor.CondorConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        attributes = settings.get_attributes()
        options = {
            'OSG_JOB_MANAGER_HOME': '/opt/condor',
            'OSG_CONDOR_LOCATION': '/opt/condor',
            'OSG_CONDOR_CONFIG': '/etc/condor/condor_config',
            'OSG_JOB_MANAGER': 'Condor'
        }
        for option in options:
            value = options[option]
            self.assertTrue(option in attributes,
                            "Attribute %s missing" % option)
            err_msg = "Wrong value obtained for %s, " \
                      "got %s instead of %s" % (option, attributes[option], value)
            self.assertEqual(attributes[option], value, err_msg)
    def testParsing(self):
        """
        Test install locations parsing
        """

        config_file = get_test_config("localsettings/local_settings1.ini")
        configuration = configparser.SafeConfigParser()
        configuration.optionxform = str
        configuration.read(config_file)

        settings = localsettings.LocalSettings(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)

        attributes = settings.get_attributes()
        self.assertTrue('test1' in attributes, 'Attribute test1 missing')
        self.assertEqual(attributes['test1'], 'Value1',
                         'Wrong value obtained for test1')

        self.assertFalse('missing_key' in attributes,
                         'Non-existent key (missing_key) found')

        self.assertFalse('default_key' in attributes,
                         'Default key recognized as a local attribute')
示例#33
0
 def test_local_settings(self):
     """
     Test to see if the local settings parsing works.
     """
     config_parser = configparser.SafeConfigParser()
     config_parser.optionxform = str
     config_file = get_test_config("subcluster/local_settings.ini")
     config_parser.read(config_file)
     local_settings = localsettings.LocalSettings(logger= \
                                                      global_logger)
     local_settings.parse_configuration(config_parser)
     attributes = local_settings.get_attributes()
     self.assertTrue(
         'default' not in attributes,
         msg="Attributes set that weren't in the test config file")
     self.assertTrue('Foo' in attributes and attributes['Foo'] == 'value1',
                     msg="Incorrectly named key." \
                         "  Desired name: Foo; only found  %s." %
                         (" ".join(attributes.keys())))
     self.assertTrue(attributes['Foo'] == 'value1',
                     msg="Incorrect value wanted value1, " \
                         "got %s" % attributes['Foo'])
     self.assertTrue('bar' in attributes and attributes['bar'] == 'value2',
                     msg="Incorrectly named key." \
                         "  Desired name: bar; only found  %s." %
                         (" ".join(attributes.keys())))
     self.assertTrue('bar' in attributes and attributes['bar'] == 'value2',
                     msg="Incorrect value wanted value2, " \
                         "got %s" % attributes['bar'])
示例#34
0
 def test_write_attribute_file(self):
     """
     Check to make sure that write_attribute_file writes out files properly
     """
     attribute_file = ("/tmp/temp_attributes.conf")
     attribute_standard = get_test_config(
         "test_files/attributes_output.conf")
     try:
         try:
             attributes = {
                 'Foo': 123,
                 'test_attr': 'abc-234#$',
                 'my-Attribute': 'test_attribute'
             }
             utilities.write_attribute_file(attribute_file, attributes)
             self.assertEqual(
                 open(attribute_file).read(),
                 open(attribute_standard).read(),
                 'Attribute files are not equal')
         except Exception as ex:
             self.fail('Got exception while testing write_attribute_file' \
                       "functionality:\n%s" % ex)
     finally:
         if os.path.exists(attribute_file):
             os.unlink(attribute_file)
示例#35
0
    def test_ini_spaces(self):
        """
        Test to make sure ini files with spaces work correctly
        """

        config_dirs = [
            get_test_config('config-space1.d'),
            get_test_config('config-space2.d'),
            get_test_config('config-space3.d')
        ]
        temp = sys.stderr
        sys.stderr = open(os.devnull, 'w')
        for directory in config_dirs:
            self.assertRaises(SystemExit,
                              configfile.read_config_files,
                              config_directory=directory)
        sys.stderr = temp
示例#36
0
 def test_new_config(self):
     """
     Make sure that we can correctly parse a correct new-style GIP config.
     """
     config_parser = configparser.SafeConfigParser()
     config_file = get_test_config("subcluster/red-new-gip-config.ini")
     config_parser.read(config_file)
     self.assertTrue(subcluster.check_config(config_parser))
    def test_valid_user_vo_file(self):
        """
        Test functionality of valid_user_vo_file function
        """

        test_file = get_test_config("./test_files/valid-user-vo-map.txt")
        self.assertTrue(validation.valid_user_vo_file(test_file, False), "Valid file flagged as invalid")

        test_file = get_test_config("./test_files/invalid-user-vo-map.txt")
        self.assertFalse(validation.valid_user_vo_file(test_file, False), "Invalid file flagged as valid")
        bad_lines = validation.valid_user_vo_file(test_file, True)[1]
        standard_lines = ["fdjkf394f023", "sam= 34f3"]
        self.assertEqual(
            bad_lines,
            standard_lines,
            "Wrong lines from the vo map obtained, " + "got:\n%s\n" % (bad_lines) + "expected:\n%s" % (standard_lines),
        )
示例#38
0
    def test_get_vos(self):
        """
        Test get_vos function
        """

        vo_file = get_test_config('test_files/sample-vos.txt')
        self.assertEqual(utilities.get_vos(vo_file), ['osg', 'LIGO', 'cdf'],
                         "Correct vos not found")
示例#39
0
    def test_jobmanager_enabled(self):
        """
        Test configurations to make sure that they are properly understood as being for a CE
        """

        config_dirs = [get_test_config('config-ce-pbs.d'),
                       get_test_config('config-ce-condor.d'),
                       get_test_config('config-ce-lsf.d'),
                       get_test_config('config-ce-sge.d')]
        for directory in config_dirs:
            config = configfile.read_config_files(config_directory=directory)
            self.assertTrue(configfile.jobmanager_enabled(config),
                            "%s has an enabled jobmanager" % directory)

        config = configfile.read_config_files(config_directory=get_test_config('config-nonce.d'))
        self.assertFalse(configfile.jobmanager_enabled(config),
                         "jobmanager_enabled returned true on a config without an enabled jobmanager")
示例#40
0
    def testServiceList(self):
        """
        Test to make sure right services get returned
        """

        config_file = get_test_config("misc/misc_xacml.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = misc.MiscConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)
        services = settings.enabled_services()
        if utilities.rpm_installed('fetch-crl'):
            expected_services = set(
                ['fetch-crl-cron', 'fetch-crl-boot', 'gums-client-cron'])
        else:
            expected_services = set(['gums-client-cron'])

        self.assertEqual(
            services, expected_services,
            "List of enabled services incorrect, " + "got %s but expected %s" %
            (services, expected_services))

        config_file = get_test_config("misc/misc_gridmap.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = misc.MiscConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception as e:
            self.fail("Received exception while parsing configuration: %s" % e)
        services = settings.enabled_services()
        if utilities.rpm_installed('fetch-crl'):
            expected_services = set(
                ['fetch-crl-cron', 'fetch-crl-boot', 'edg-mkgridmap'])
        else:
            expected_services = set(['edg-mkgridmap'])

        self.assertEqual(
            services, expected_services,
            "List of enabled services incorrect, " + "got %s but expected %s" %
            (services, expected_services))
示例#41
0
 def test_doherty(self):
     """
     Make sure that we can correctly parse a correct new-style GIP config.
     """
     config_parser = ConfigParser.SafeConfigParser()
     config_file = get_test_config("gip/doherty.ini")
     config_parser.read(config_file)
     gip_config = gip.GipConfiguration(logger=global_logger)
     gip_config._parse_configuration(config_parser)
示例#42
0
    def test_get_vos(self):
        """
        Test get_vos function
        """

        vo_file = get_test_config('test_files/sample-vos.txt')
        self.assertEqual(utilities.get_vos(vo_file),
                         ['osg', 'LIGO', 'cdf'],
                         "Correct vos not found")
示例#43
0
 def test_no_name(self):
     """
     Make sure a missing name causes an error
     """
     config_parser = ConfigParser.SafeConfigParser()
     config_file = get_test_config("gip/sc_samples.ini")
     config_parser.read(config_file)
     gip_config = gip.GipConfiguration(logger=global_logger)
     self.assertRaises(exceptions.SettingError, gip_config.check_sc, config_parser, "Subcluster No Name")
示例#44
0
 def test_old_config(self):
     """
     Make sure that we can correctly parse an old-style GIP config.
     """
     config_parser = ConfigParser.SafeConfigParser()
     config_file = get_test_config("gip/red-old-gip-config.ini")
     config_parser.read(config_file)
     gip_config = gip.GipConfiguration(logger=global_logger)
     gip_config._parse_configuration(config_parser)
示例#45
0
 def test_resource_entry(self):
     """
     Make sure a Resource Entry section is detected
     """
     config_parser = ConfigParser.SafeConfigParser()
     config_file = get_test_config("gip/resourceentry.ini")
     config_parser.read(config_file)
     gip_config = gip.GipConfiguration(logger=global_logger)
     found_scs = gip_config.check_subclusters(config_parser)
     self.assertTrue(found_scs, msg="Resource Entry Valid not found.")
    def test_valid_location(self):
        """
        Check the valid_location functionality
        """

        test_location = get_test_config("misc/misc1.ini")
        self.assertTrue(validation.valid_location(test_location), "%s not marked as a valid location" % test_location)

        test_location = "configs/invalid_foo.config"
        self.assertFalse(validation.valid_location(test_location), "%s marked as a valid location" % test_location)
示例#47
0
    def testMissingLSFProfile(self):
        """
        Test the check_attributes function to see if it catches missing LSF profile
        """
        config_file = get_test_config("lsf/missing_profile.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = lsf.LSFConfiguration(logger=global_logger)
        self.assertRaises(exceptions.SettingError, settings.parse_configuration, configuration)
    def test_valid_file_location(self):
        """
        Check the valid_file functionality
        """
        test_file = get_test_config("utilities/valid_boolean.ini")
        message = "%s not marked as a valid file location" % test_file
        self.assertTrue(validation.valid_location(test_file), message)

        test_file = "configs/invalid_foo.config"
        message = "%s marked as a valid file location" % test_file
        self.assertFalse(validation.valid_location(test_file), message)
示例#49
0
    def load_settings_from_files(self, *cfgfiles):
        configuration = ConfigParser.SafeConfigParser()
        for cfgfile in cfgfiles:
            configuration.read(get_test_config(cfgfile))

        settings = rsv.RsvConfiguration(logger=global_logger)
        settings.rsv_meta_dir = RSV_META_DIR
        try:
            settings.parse_configuration(configuration)
        except Exception, e:
            self.fail("Received exception while parsing configuration: %s" % e)
 def test_valid_boolean(self):
     """
     Test functionality of valid_boolean function
     """
     config_file = get_test_config("utilities/valid_boolean.ini")
     config = ConfigParser.SafeConfigParser()
     config.read(config_file)
     self.assertFalse(validation.valid_boolean(config, "Test", "invalid_bool"), "invalid_bool flagged as valid")
     self.assertFalse(validation.valid_boolean(config, "Test", "invalid_bool2"), "invalid_bool2 flagged as valid")
     self.assertFalse(validation.valid_boolean(config, "Test", "missing"), "invalid_bool2 flagged as valid")
     self.assertTrue(validation.valid_boolean(config, "Test", "valid_bool"), "valid_bool flagged as invalid")
     self.assertTrue(validation.valid_boolean(config, "Test", "valid_bool2"), "valid_bool2 flagged as invalid")
    def testInvalidBDII1(self):
        """
        Test the check_attributes function to see if it catches invalid
        bdii servers
        """

        config_file = get_test_config("infoservices/invalid_bdii1.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = infoservices.InfoServicesConfiguration(logger=global_logger)
        self.assertRaises(exceptions.SettingError, settings.parse_configuration, configuration=configuration)
    def test_valid_executable(self):
        """
        Test functionality of valid_executable function
        """

        binary = "/bin/ls"
        text = get_test_config("test_files/subscriptions.xml")
        missing = "./test_files/foo"

        self.assertFalse(validation.valid_executable(missing), "Non-existent file is not a valid executable")
        self.assertFalse(validation.valid_executable(text), "Text file is not a valid executable")
        self.assertTrue(validation.valid_executable(binary), "/bin/ls should be a valid binary")
示例#53
0
    def testValidSettings2(self):
        """
        Test the check_attributes function to see if it works on valid settings
        """
        config_file = get_test_config("slurm/check_ok2.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = slurm.SlurmConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception, e:
            self.fail("Received exception while parsing configuration: %s" % e)
示例#54
0
    def testMissingCondorConfig(self):
        """
        Test the check_attributes function to see if it catches missing
        condor config locations
        """

        for filename in [get_test_config("condor/missing_config1.ini"),
                         get_test_config("condor/missing_config2.ini")]:
            config_file = os.path.abspath(filename)
            configuration = ConfigParser.SafeConfigParser()
            configuration.read(config_file)

            settings = condor.CondorConfiguration(logger=global_logger)
            try:
                settings.parse_configuration(configuration)
            except Exception, e:
                self.fail("Received exception while parsing configuration: %s" % e)

            attributes = settings.get_attributes()
            self.assertFalse(settings.check_attributes(attributes),
                             "Did not notice missing condor config location: " +
                             attributes['OSG_CONDOR_CONFIG'])
    def test_valid_file(self):
        """
        Test functionality of valid_file function
        """

        filename = get_test_config("utilities/newline.ini")
        _stderr = sys.stderr
        sys.stderr = file(os.devnull, "wb")
        # need to do this instead of putting this in assert so that stderr can
        # be restored after call
        result = validation.valid_ini_file(filename)
        self.assertFalse(result, "Didn't detect newline in %s" % filename)
        # test whether we catch sections that has a space before the first setting
        filename = get_test_config("utilities/section_space.ini")
        self.assertFalse(result, "Didn't detect space in %s" % filename)
        sys.stderr = _stderr

        filename = get_test_config("utilities/valid_boolean.ini")
        self.assertTrue(validation.valid_ini_file(filename), "Got error on valid file %s" % filename)

        filename = get_test_config("utilities/valid_variable.ini")
        self.assertTrue(validation.valid_ini_file(filename), "Got error on valid file %s" % filename)
示例#56
0
    def testValidProductionDefaults(self):
        """
        Test the production defaults and make sure that they are valid
        """
        config_file = get_test_config("gratia/prod_default.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = gratia.GratiaConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception, e:
            self.fail("Received exception while parsing configuration: %s" % e)
    def testMissingAttribute(self):
        """
        Test the parsing when attributes are missing, should get exceptions
        """
        config_file = get_test_config("siteattributes/siteattributes2.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = siteattributes.SiteAttributes(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception, e:
            self.fail("Received exception while parsing configuration: %s" % e)
示例#58
0
    def testMissingPBSLocation(self):
        """
        Test the check_attributes function to see if it catches missing pbs location
        """
        config_file = get_test_config("slurm/missing_location.ini")
        configuration = ConfigParser.SafeConfigParser()
        configuration.read(config_file)

        settings = slurm.SlurmConfiguration(logger=global_logger)
        try:
            settings.parse_configuration(configuration)
        except Exception, e:
            self.fail("Received exception while parsing configuration: %s" % e)
示例#59
0
 def test_changeme1(self):
     """
     Test should pass if SE CHANGEME section is disabled.
     """
     did_fail = False
     try:
         config_parser = ConfigParser.SafeConfigParser()
         config_file = get_test_config("gip/changeme_section.ini")
         config_parser.read(config_file)
         gip_config = gip.GipConfiguration(logger=global_logger)
         gip_config._parse_configuration(config_parser)
     except exceptions.SettingError:
         did_fail = True
     self.assertFalse(did_fail, msg="Falsely detected an enabled CHANGEME section.")
示例#60
0
 def test_hepspec_valid(self):
     """
     Make sure a valid HEPSPEC value is accepted.
     """
     did_fail = False
     config_parser = ConfigParser.SafeConfigParser()
     config_file = get_test_config("gip/sc_samples.ini")
     config_parser.read(config_file)
     gip_config = gip.GipConfiguration(logger=global_logger)
     try:
         gip_config.check_sc(config_parser, "Subcluster Valid")
     except exceptions.SettingError:
         did_fail = True
     self.assertFalse(did_fail, msg="Valid HEPSPEC entry threw an exception.")