def main(): arg_parser = argparse.ArgumentParser() arg_parser.add_argument( "path", help="Chemin du fichier de config à visualiser") arg_parser.add_argument( "module", help="Précise le module dans lequel se trouve le fichier de config") args = arg_parser.parse_args() parser = ExtendedConfigParser( config=environ.get("MFCONFIG", "GENERIC"), strict=False, inheritance='im') data = codecs.open(args.path, "r", "utf-8") module = args.module home_env = str(module) + "_HOME" home = environ.get(home_env) parser.read_file(data) res_dict = read_config_file(parser, parser.config_name, home) for s in res_dict: for o in res_dict[s]: print("export " + module.upper() + "_" + s.upper() + "_" + o.upper() + "=\"" + str(res_dict[s][o]) + "\"") print("export %s_CONF_GENERATION_TIME=%i" % (module.upper(), time.time()))
def init(self): self.in_dir = os.environ['MFDATA_DATA_IN_DIR'] conf_file = os.path.join(os.environ['MODULE_RUNTIME_HOME'], "tmp", "config_auto", "switch.ini") if not os.path.exists(conf_file): self.error_and_die("no switch configuration file") self.condition_tuples = [] parser = ExtendedConfigParser(config=CONFIG, strict=False, inheritance='im', interpolation=None) parser.read(conf_file) sections = parser.sections() for section in sections: directory = parser.get(section, "directory").strip() plugin_name = parser.get(section, "plugin_name").strip() condition = parser.get(section, "condition").strip() magic_file = parser.get(section, "magic_file").strip() use_hardlink = parser.getboolean(section, "use_hardlink") if magic_file.lower() in ('null', 'none'): magic_file = None self.condition_tuples.append( (plugin_name, condition, directory, magic_file, use_hardlink)) self.no_match_policy = self.args.no_match_policy if self.no_match_policy not in ('keep', 'delete', 'move'): self.error_and_die("unknown no-match policy: %s", self.no_match_policy) if self.no_match_policy == "move": nmpmdd = self.args.no_match_policy_move_dest_dir if nmpmdd is None: self.error_and_die('you have to set a ' 'no-match-policy-move-dest-dir' ' in case of move no-match policy') mkdir_p_or_die(nmpmdd)
def main(): arg_parser = argparse.ArgumentParser() arg_parser.add_argument("path", help="Chemin du fichier de config à visualiser") arg_parser.add_argument( "module", help="Précise le module dans lequel se trouve le fichier de config") args = arg_parser.parse_args() parser = ExtendedConfigParser(config=environ.get("MFCONFIG", "GENERIC"), strict=False, inheritance='im') data = codecs.open(args.path, "r", "utf-8") module = args.module home_env = str(module) + "_HOME" home = environ.get(home_env) parser.read_file(data) res_dict = read_config_file(parser, parser.config_name, home) for s in res_dict: for o in res_dict[s]: print("export " + module.upper() + "_" + s.upper() + "_" + o.upper() + "=\"" + str(res_dict[s][o]) + "\"") print("export %s_CONF_GENERATION_TIME=%i" % (module.upper(), time.time()))
def build_plugin(plugin_path, plugins_base_dir=None): plugin_path = os.path.abspath(plugin_path) plugins_base_dir = _get_plugins_base_dir(plugins_base_dir) base = os.path.join(plugins_base_dir, "base") pwd = os.getcwd() parser = ExtendedConfigParser(config=os.environ.get('MFCONFIG', 'GENERIC'), strict=False, inheritance="im") with open(os.path.join(plugin_path, "config.ini"), "r") as f: config_content = f.read() if six.PY2: parser.read_string(config_content.decode('utf-8')) else: parser.read_string(config_content) name = parser['general']['name'] version = parser['general']['version'] summary = parser['general']['summary'] license = parser['general']['license'] try: packager = parser['general']['packager'] except Exception: packager = parser['general']['maintainer'] vendor = parser['general']['vendor'] url = parser['general']['url'] tmpdir = os.path.join(RUNTIME_HOME, "tmp", "plugin_%s" % get_unique_hexa_identifier()) mkdir_p_or_die(os.path.join(tmpdir, "BUILD")) mkdir_p_or_die(os.path.join(tmpdir, "RPMS")) mkdir_p_or_die(os.path.join(tmpdir, "SRPMS")) _make_plugin_spec(os.path.join(tmpdir, "specfile.spec"), name, version, summary, license, packager, vendor, url) cmd = "source %s/lib/bash_utils.sh ; " % MFEXT_HOME cmd = cmd + "layer_load rpm@mfext ; " cmd = cmd + 'rpmbuild --define "_topdir %s" --define "pwd %s" ' \ '--define "prefix %s" --dbpath %s ' \ '-bb %s/specfile.spec' % (tmpdir, plugin_path, tmpdir, base, tmpdir) x = BashWrapperOrRaise(cmd, MFUtilPluginCantBuild, "can't build plugin %s" % plugin_path) tmp = glob.glob(os.path.join(tmpdir, "RPMS", "x86_64", "*.rpm")) if len(tmp) == 0: raise MFUtilPluginCantBuild("can't find generated plugin" % plugin_path, bash_wrapper=x) plugin_path = tmp[0] new_basename = \ os.path.basename(plugin_path).replace("x86_64.rpm", "metwork.%s.plugin" % MODULE_LOWERCASE) new_plugin_path = os.path.join(pwd, new_basename) shutil.move(plugin_path, new_plugin_path) shutil.rmtree(tmpdir, True) os.chdir(pwd) return new_plugin_path
def test_set_config_separator(self): self.x = ExtendedConfigParser(config='dev#dem#der', section_separator='%', list_separator='*') self.x.read('./test_cfg_kwargs.ini') self.x.set_config_separator('#') self.assertEqual(self.x.get('sect1', 'key1'), 'dev1')
def test_set_section_separator_fail(self): self.x = ExtendedConfigParser(config='', config_separator='#', list_separator='*') self.x.read('./test_cfg_kwargs.ini') self.x.set_section_separator('%') self.assertEqual(self.x.get('sect1', 'key3'), 'val3')
def test_set_list_separator_wrong(self): self.x = ExtendedConfigParser(config='dev', config_separator='#', section_separator='%') self.x.read('./test_cfg_kwargs.ini') self.x.set_list_separator('*') self.assertEqual(self.x.get('sect1', 'key_list'), 'damn;dang;nabbit')
def test_set_list_separator(self): self.x = ExtendedConfigParser(config='dev', config_separator='#', section_separator='%') self.x.read('./test_cfg_kwargs.ini') self.x.set_list_separator('*') self.assertEqual(self.x.get('sect1', 'key2', isList=True), ['dev2', '2ved', '2vedev2'])
def main(): arg_parser = argparse.ArgumentParser( description="Lit le contenu d'un fichier .ini") arg_parser.add_argument( "path", help="Chemin du fichier de config a visualiser") arg_parser.add_argument( "section", help="Precise la section a afficher", nargs='?', default=None) arg_parser.add_argument( "option", help="Precise l'option a afficher", nargs='?', default=None) arg_parser.add_argument( "config", help="Precise la config a utiliser pour l'affichage", nargs='?', default=None) args = arg_parser.parse_args() if(args.config): parser = ExtendedConfigParser(config="NULL", strict=False, inheritance='im') else: parser = ExtendedConfigParser( config=environ.get("SYNCONFIG", "GENERIC"), strict=False, inheritance='im') data = codecs.open(str(args.path), "r", "utf-8") parser.read_file(data) if(args.section): # Affichage de la valeur d'une option if(args.option): print_option(parser, args.section, args.option) # Affichage du contenu d'une section else: print_section(parser, args.section) # Affichage de l'ensemble des sections du fichier else: print_file(parser)
def read_config_file(parser, config, home): res = OrderedDict() for s in parser._sections: # On inclut les sections des fichiers de config à inclure if (s.startswith("INCLUDE_")): parser_included = ExtendedConfigParser(config=config, inheritance='im') included_file = s[8:] data = codecs.open(home + "/config/" + included_file, "r", "utf-8") parser_included.read_file(data) res.update(read_config_file(parser_included, config, home)) # On ajoute la section si elle n'y est pas ou on la met à jour # si elle a été incluse auparavant else: try: res[s].update(read_section(parser, s, home)) except KeyError: res[s] = read_section(parser, s, home) return res
def read_config_file(parser, config, home): res = OrderedDict() for s in parser._sections: # On inclut les sections des fichiers de config à inclure if(s.startswith("INCLUDE_")): parser_included = ExtendedConfigParser(config=config, inheritance='im') included_file = s[8:] data = codecs.open(home + "/config/" + included_file, "r", "utf-8") parser_included.read_file(data) res.update(read_config_file(parser_included, config, home)) # On ajoute la section si elle n'y est pas ou on la met à jour # si elle a été incluse auparavant else: try: res[s].update(read_section(parser, s, home)) except KeyError: res[s] = read_section(parser, s, home) return res
class InheritanceTestCase(unittest.TestCase): def setUp(self): self.x = ExtendedConfigParser() self.x.read('./test_cfg.ini') def test_get_section_name(self): self.assertEqual(self.x.get_section_name('sect1'), 'sect1:sect2:sect3') def test_get_section_name_fail(self): self.assertRaises(NoSectionError, self.x.get_section_name, 'sect4') def test_get_basic2(self): self.assertEqual(self.x.get('sect1', 'key1'), 'val1') def test_get_basic_fail2(self): self.assertRaises(NoOptionError, self.x.get, 'sect1', 'key412') def test_get_sections(self): sections = ['sect1:sect2:sect3', 'sect2', 'sect3'] self.assertEqual(self.x.get_corresponding_sections('sect1'), sections) def test_get_sections_fail(self): self.assertRaises(NoSectionError, lambda: self.x.get_corresponding_sections('sect173')) def test_get_parent_key(self): self.assertEqual(self.x.get('sect1', 'key2'), 'val2') def test_get_grandparent_key(self): self.assertEqual(self.x.get('sect1', 'key3'), 'val3') def test_get_key_dict(self): self.assertEqual(self.x['sect1']['key1'], 'val1') def test_get_parent_key_dict(self): self.assertEqual(self.x['sect1']['key2'], 'val2') def test_get_grandparent_key_dict(self): self.assertEqual(self.x['sect1']['key3'], 'val3') def test_get_default_key_dict(self): self.assertEqual(self.x['sect1']['key049'], 'DEFAULT') def test_get_key_dict_fail(self): self.assertRaises(KeyError, lambda: self.x['sect2']['key4']) def test_get_sect_dict_fail(self): self.assertRaises(KeyError, lambda: self.x['sect42']['key1'])
def test_get_kwargs(self): self.x = ExtendedConfigParser(config='dev', config_separator='#', section_separator='%', list_separator='*', delimiters=':', comment_prefixes=('#', ';'), inline_comment_prefixes=None, strict=True, empty_lines_in_values=True, default_section='THINGY', interpolation=None) self.x.read('./test_cfg_kwargs.ini') self.assertEqual(self.x.get('sect1', 'key2', isList=True), ['dev2', '2ved', '2vedev2'])
def parse(self, stream): """Parses the keys and values from a config file. NOTE: For keys that were specified to configargparse as action="store_true" or "store_false", the config file value must be one of: "yes", "no", "true", "false". Otherwise an error will be raised. Args: stream: A config file input stream (such as an open file object). Returns: OrderedDict of items where the keys have type string and the values have type either string or list (eg. to support config file formats like YAML which allow lists). """ f = self.custom_environment_callable f(self.plugin_name, self.step_name) config = os.environ.get('MFCONFIG', 'GENERIC') config_parser = ExtendedConfigParser(config=config, inheritance='im', interpolation=None) content = stream.read() if (sys.version_info < (3, 0)): content = content.decode("utf-8") config_parser.read_string(content) section = "step_%s" % self.step_name result = collections.OrderedDict() for key in config_parser.options(section): if not key.startswith('arg_'): continue if (sys.version_info < (3, 0)): result[key.replace('arg_', '', 1)] = envtpl.render_string( config_parser.get(section, key), keep_multi_blank_lines=False).encode('utf-8') else: result[key.replace('arg_', '', 1)] = envtpl.render_string( config_parser.get(section, key), keep_multi_blank_lines=False) return result
def main(): arg_parser = argparse.ArgumentParser( description="Lit le contenu d'un fichier .ini") arg_parser.add_argument("path", help="Chemin du fichier de config a visualiser") arg_parser.add_argument("section", help="Precise la section a afficher", nargs='?', default=None) arg_parser.add_argument("option", help="Precise l'option a afficher", nargs='?', default=None) arg_parser.add_argument( "config", help="Precise la config a utiliser pour l'affichage", nargs='?', default=None) args = arg_parser.parse_args() if (args.config): parser = ExtendedConfigParser(config="NULL", strict=False, inheritance='im') else: parser = ExtendedConfigParser(config=environ.get( "SYNCONFIG", "GENERIC"), strict=False, inheritance='im') data = codecs.open(str(args.path), "r", "utf-8") parser.read_file(data) if (args.section): # Affichage de la valeur d'une option if (args.option): print_option(parser, args.section, args.option) # Affichage du contenu d'une section else: print_section(parser, args.section) # Affichage de l'ensemble des sections du fichier else: print_file(parser)
def test_read_file(self): self.x = ExtendedConfigParser() data = open('./test_cfg.ini', 'r') self.x.read_file(data) self.assertEqual(self.x.get('sect2', 'key2'), 'val2')
class AdvancedTestCase(unittest.TestCase): def setUp(self): self.x = ExtendedConfigParser() self.x.read('./test_cfg.ini') def test_get_not_list(self): res = 'damn;dang;nabbit' self.assertEqual(self.x.get('sect1', 'key_list'), res) def test_get_list(self): res = ['damn', 'dang', 'nabbit'] self.assertEqual(self.x.get('sect1', 'key_list', isList=True), res) def test_get_list_int(self): res = [1, 7, 3] self.assertEqual(self.x.getintlist('sect1', 'key_list_int'), res) def test_get_list_bool(self): res = [True, False, True] self.assertEqual(self.x.getbooleanlist('sect1', 'key_list_bool'), res) def test_get_list_float(self): res = [0.96, 1.73, 6.82] self.assertEqual(self.x.getfloatlist('sect1', 'key_list_float'), res) def test_get_fallback_list(self): # If not found in the section or parents (tests list for defaults, # fallback, father,...) self.assertEqual(self.x.get('sect1', 'key173', fallback='deez', isList=True), ['deez']) def test_get_father(self): self.x = ExtendedConfigParser(defaults={'key4': 'father'}) self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect1', 'key4'), 'father') def test_get_default_over_father(self): self.x = ExtendedConfigParser(defaults={'key049': 'father'}) self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect1', 'key049'), 'DEFAULT') def test_get_config_plus(self): self.x = ExtendedConfigParser(config='mem_plop_toto') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect3', 'key3', cfg_plus=True), 'toto3') def test_get_config_section_loop_basic(self): self.x = ExtendedConfigParser(config='dev_plop_toto') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect1', 'key1', sect_first=False), 'dev_plop_toto1_sect3') def test_get_config_section_loop_default(self): self.x = ExtendedConfigParser(config='dev_plop_toto_stuff') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect1', 'key1', sect_first=False), 'dev_plop_toto1_default') def test_get_config_section_loop_father(self): self.x = ExtendedConfigParser(config='dev_plop_toto_stuff', defaults={'key049[dev_plop]': 'father'}) self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect1', 'key049', sect_first=False), 'father') def test_get_config_section_loop_vars_specified(self): self.x = ExtendedConfigParser(config='dev_plop_toto_stuff') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect1', 'key1', sect_first=False, vars={'key1[dev_plop_toto_stuff]': 'vars'}), 'vars') def test_get_config_section_loop_vars(self): self.x = ExtendedConfigParser(config='mem_plop_toto_stuff') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect2', 'key1', sect_first=False, vars={'key1': 'vars'}), 'vars') def test_get_config_section_loop_vars_unspecified(self): self.x = ExtendedConfigParser() self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect2', 'key1', sect_first=False, vars={'key1': 'vars'}), 'vars') def test_get_config_section_loop_sect_unspecified(self): self.x = ExtendedConfigParser(config='dev_plop') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect2', 'key1', sect_first=False), 'val1_sect2') def test_get_config_section_loop_default_unspecified(self): self.x = ExtendedConfigParser(config='mem_plop') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect2', 'key049', sect_first=False), 'DEFAULT') def test_get_config_section_loop_father_unspecified(self): self.x = ExtendedConfigParser(config='mem_plop', defaults={'key096': 'father'}) self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect2', 'key096', sect_first=False), 'father') def test_get_config_section_loop_fallback(self): self.assertEqual(self.x.get('sect2', 'key173', sect_first=False, fallback='SCP-173'), 'SCP-173') def test_get_config_section_loop_fail(self): self.assertRaises(NoOptionError, self.x.get, 'sect1', 'key682', sect_first=False) def test_get_config_section_loop_config_plus(self): self.x = ExtendedConfigParser(config='mem_plop_toto') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect3', 'key3', sect_first=False, cfg_plus=True), 'toto3') def test_get_config_section_loop_list(self): self.assertEqual(self.x.get('sect2', 'key173', sect_first=False, fallback='SCP-173', isList=True), ['SCP-173']) def test_get_kwargs(self): self.x = ExtendedConfigParser(config='dev', config_separator='#', section_separator='%', list_separator='*', delimiters=':', comment_prefixes=('#', ';'), inline_comment_prefixes=None, strict=True, empty_lines_in_values=True, default_section='THINGY', interpolation=None) self.x.read('./test_cfg_kwargs.ini') self.assertEqual(self.x.get('sect1', 'key2', isList=True), ['dev2', '2ved', '2vedev2']) def test_set_config_separator(self): self.x = ExtendedConfigParser(config='dev#dem#der', section_separator='%', list_separator='*') self.x.read('./test_cfg_kwargs.ini') self.x.set_config_separator('#') self.assertEqual(self.x.get('sect1', 'key1'), 'dev1') def test_set_config_separator_wrong(self): self.x = ExtendedConfigParser(config='dev_dem_der', section_separator='%', list_separator='*') self.x.read('./test_cfg_kwargs.ini') self.x.set_config_separator('#') self.x.set_config_name('dev_dem_der') self.assertEqual(self.x.get('sect1', 'key1'), 'val1') def test_set_section_separator(self): self.x = ExtendedConfigParser(config='', config_separator='#', list_separator='*') self.x.read('./test_cfg_kwargs.ini') self.x.set_section_separator('%') self.assertEqual(self.x.get('sect1', 'key3'), 'val3') def test_set_section_separator_fail(self): self.x = ExtendedConfigParser(config='', config_separator='#', list_separator='*') self.x.read('./test_cfg_kwargs.ini') self.x.set_section_separator('%') self.assertEqual(self.x.get('sect1', 'key3'), 'val3') def test_set_list_separator(self): self.x = ExtendedConfigParser(config='dev', config_separator='#', section_separator='%') self.x.read('./test_cfg_kwargs.ini') self.x.set_list_separator('*') self.assertEqual(self.x.get('sect1', 'key2', isList=True), ['dev2', '2ved', '2vedev2']) def test_set_list_separator_wrong(self): self.x = ExtendedConfigParser(config='dev', config_separator='#', section_separator='%') self.x.read('./test_cfg_kwargs.ini') self.x.set_list_separator('*') self.assertEqual(self.x.get('sect1', 'key_list'), 'damn;dang;nabbit') def test_get_section_name_compact_basic(self): self.assertEqual(self.x.get_section_name_compact('sect2'), 'sect2') def test_get_section_name_compact_parents(self): self.assertEqual(self.x.get_section_name_compact('sect1:sect2:sect3'), 'sect1') def test_get_first_section(self): self.assertEqual(self.x.get_first_section(), 'sect1')
def setUp(self): self.x = ExtendedConfigParser(config='dev') self.x.read('./test_cfg.ini')
class SpecificationTestCase(unittest.TestCase): def setUp(self): self.x = ExtendedConfigParser(config='dev') self.x.read('./test_cfg.ini') def test_get_config_name(self): self.assertEqual(self.x.get_config_name(), 'dev') def test_specification_basic_unspeced_key(self): self.assertEqual(self.x.get('sect2', 'key1'), 'val1_sect2') def test_specification_basic(self): self.assertEqual(self.x.get('sect1', 'key1'), 'dev1') def test_specification_goto_parent_config(self): self.x.set_config_name('dev_stuff') self.assertEqual(self.x.get('sect1', 'key1'), 'dev1') def test_specification_goto_grandparent(self): self.x.set_config_name('dev_dem_der') self.assertEqual(self.x.get('sect1', 'key1'), 'dev1') def test_get_configs(self): self.x.set_config_name('dev_plop_toto') res = ['dev_plop_toto', 'dev_plop', 'dev'] self.assertEqual(self.x.get_configs(), res) def test_get_configs_param(self): res = ['dev_plop_toto', 'dev_plop', 'dev'] self.assertEqual(self.x.get_configs('dev_plop_toto'), res) def test_get_configs_plus(self): self.x.set_config_name('dev_plop_toto') res = ['dev_plop_toto', 'plop_toto', 'toto', 'dev_plop', 'plop', 'dev'] self.assertEqual(self.x.get_configs_plus(), res) def test_get_configs_plus_param(self): res = ['dev_plop_toto', 'plop_toto', 'toto', 'dev_plop', 'plop', 'dev'] self.assertEqual(self.x.get_configs_plus('dev_plop_toto'), res) def test_specification_advanced(self): self.x.set_config_name('dev_plop_toto') self.assertEqual(self.x.get('sect3', 'key3'), 'dev_plop_toto3') def test_get_specified_defaults(self): self.assertEqual(self.x.get('sect3', 'key049'), 'DEFAULT_dev') def test_get_specified_vars(self): self.assertEqual(self.x.get('sect1', 'key1', vars={'key1[dev]': 'deez'} ), 'deez')
def test_get_config_section_loop_default_unspecified(self): self.x = ExtendedConfigParser(config='mem_plop') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect2', 'key049', sect_first=False), 'DEFAULT')
def init(): global monitors, inactivityTimeout, logger if monitors: # Init already performed return True arg_parser = ArgumentParser() arg_parser.add_argument('-c', '--config', help='Configuration filename ' '( absolute or relative path to a directory under ' 'module home directory )') args = arg_parser.parse_args() homedir = None try: if args.config is None: logger.critical("you must provide a configuration file") sys.exit(1) if args.config.startswith('~'): args.config = os.path.abspath(args.config) if args.config.startswith('/'): ficconfig = args.config if not os.path.exists(ficconfig): logger.critical("File %s does not exist or is not accessible" % ficconfig) ficconfig = None else: ficconfig = None homedir = os.environ[os.environ['MFMODULE'] + '_HOME'] for directory in DEFAULT_HOME_CONFIG_DIRS: ficconfig = os.path.abspath(homedir) ficconfig = os.path.join(ficconfig, directory) ficconfig = os.path.join(ficconfig, args.config) if os.path.exists(ficconfig): break ficconfig = None if not ficconfig: logger.info("File %s not found under standard configuration" " directories") pass except KeyError: logger.critical("Can't obtain Module home directory") ficconfig = None if ficconfig and os.path.isdir(ficconfig): logger.critical("%s is a directory !" % ficconfig) ficconfig = None if not ficconfig: return False parser = ExtendedConfigParser(config=environ.get("MFCONFIG", "GENERIC"), strict=False, inheritance='im') data = codecs.open(ficconfig, "r", "utf-8") try: parser.read_file(data) except Exception: logger.critical('Error Loading config: %s' % ficconfig) return False Monitor.server = None Monitor.port = None Monitor.redis = None Monitor.unix_socket = None Monitor.wm = None monitor_inactivitytimeout = None monitors = [] for s in parser._sections: mon = Monitor() active = False key = 'active' if parser.has_option(s, key): active = parser.getboolean(s, key) if not active: continue key = 'redis_server' if not parser.has_option(s, key): continue server = parser[s][key] if Monitor.server is None: Monitor.server = server elif Monitor.server != server: logger.critical('Only 1 redis server Please') return False key = 'redis_unix_socket' if not parser.has_option(s, key): continue unix_socket = parser[s][key] if len(unix_socket) == 0 or unix_socket == "null": unix_socket = None Monitor.unix_socket = unix_socket key = 'redis_port' if not parser.has_option(s, key): continue port = parser.getint(s, key) if Monitor.port is None: Monitor.port = port elif Monitor.port != port: logger.critical('Only 1 redis port Please') return False key = 'monitor_inactivitytimeout' if parser.has_option(s, key): timeout = parser.getint(s, key) if timeout <= 0: # Standardization timeout = -1 if monitor_inactivitytimeout is None: monitor_inactivitytimeout = timeout inactivityTimeout = timeout elif monitor_inactivitytimeout != timeout: logger.critical('Only 1 monitor_inactivitytimeout Please') return False key = 'directory' if not parser.has_option(s, key): continue mon.dir = parser[s][key] key = 'queue' if not parser.has_option(s, key): continue mon.redisqueue = parser[s][key] if not mon.redisqueue: logger.critical('Invalid redis queue name') continue q = mon.redisqueue.replace('queue:', '').replace('out_', 'out.') q = re.sub(r'stage(\d+)_', r'stage\1.', q) key = 'timeout' if parser.has_option(s, key): mon.redistimeout = parser.getint(s, key) key = 'forced_poll' if parser.has_option(s, key): mon.tpolling = parser.getint(s, key) key = 'poll_queue_limit' if parser.has_option(s, key): mon.pollinglimit = parser.getint(s, key) key = 'only' if parser.has_option(s, key): mon.only = getMask(parser[s][key]) key = 'ignore' cnfgignorestr = None if parser.has_option(s, key): cnfgignorestr = parser[s][key] mon.ignore = getMask(cnfgignorestr, (r'^.*\.working$', )) monitors.append(mon) if not monitors or len(monitors) < 1: logger.critical('No directory to scan') return False return True
def test_get_config_section_loop_default(self): self.x = ExtendedConfigParser(config='dev_plop_toto_stuff') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect1', 'key1', sect_first=False), 'dev_plop_toto1_default')
def test_get_config_section_loop_father(self): self.x = ExtendedConfigParser(config='dev_plop_toto_stuff', defaults={'key049[dev_plop]': 'father'}) self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect1', 'key049', sect_first=False), 'father')
def test_get_config_section_loop_vars(self): self.x = ExtendedConfigParser(config='mem_plop_toto_stuff') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect2', 'key1', sect_first=False, vars={'key1': 'vars'}), 'vars')
def test_get_config_section_loop_vars_unspecified(self): self.x = ExtendedConfigParser() self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect2', 'key1', sect_first=False, vars={'key1': 'vars'}), 'vars')
def test_get_config_section_loop_config_plus(self): self.x = ExtendedConfigParser(config='mem_plop_toto') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect3', 'key3', sect_first=False, cfg_plus=True), 'toto3')
def test_defaults(self): self.x = ExtendedConfigParser(defaults={'william': 'Overbeck'}) self.x.read('./test_cfg.ini') res = OrderedDict([('william', 'Overbeck')]) self.assertEquals(self.x.defaults(), res)
def test_get_default_over_father(self): self.x = ExtendedConfigParser(defaults={'key049': 'father'}) self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect1', 'key049'), 'DEFAULT')
class BasicTestCase(unittest.TestCase): def setUp(self): self.x = ExtendedConfigParser() self.x.read('./test_cfg.ini') def test_basic(self): self.assertTrue(self.x is not None) def test_get_basic(self): self.assertEqual(self.x.get('sect2', 'key2'), 'val2') def test_get_basic_fail(self): self.assertRaises(NoOptionError, self.x.get, 'sect2', 'key4') def test_get_basic_fail2(self): self.assertRaises(NoSectionError, self.x.get, 'sect4', 'key3') def test_get_int(self): self.assertEqual(self.x.getint('sect1', 'key_int'), 1) def test_get_float(self): self.assertEqual(self.x.getfloat('sect1', 'key_float'), 1.24) def test_get_boolean_true(self): self.assertTrue(self.x.getboolean('sect1', 'key_bool1')) def test_get_boolean_on(self): self.assertTrue(self.x.getboolean('sect1', 'key_bool2')) def test_get_boolean_1(self): self.assertTrue(self.x.getboolean('sect1', 'key_bool3')) def test_get_boolean_yes(self): self.assertTrue(self.x.getboolean('sect1', 'key_bool4')) def test_get_boolean_false(self): self.assertFalse(self.x.getboolean('sect1', 'key_bool5')) def test_get_boolean_random(self): self.assertRaises(ValueError, self.x.getboolean, 'sect1', 'key_bool6') def test_default(self): self.assertEqual(self.x.get('sect3', 'key2'), 'default2') def test_default_section(self): default = OrderedDict([('key1[dev_plop_toto_stuff]', 'dev_plop_toto1_default'), ('key2', 'default2'), ('key3', 'default3'), ('key049', 'DEFAULT'), ('key049[dev]', 'DEFAULT_dev')]) self.assertEqual(self.x.default_section, default) def test_get_vars(self): self.assertEqual(self.x.get('sect1', 'key1', vars={'key1': 'deez'}), 'deez') def test_get_fallback(self): self.assertEqual(self.x.get('sect1', 'key173', fallback='deez'), 'deez') def test_has_section(self): self.assertTrue(self.x.has_section('sect2')) def test_has_section_advanced(self): self.assertTrue(self.x.has_section('sect1')) def test_has_section_fail(self): self.assertFalse(self.x.has_section('sect42')) def test_has_option(self): self.assertTrue(self.x.has_option('sect3', 'key3')) def test_has_option_config(self): self.assertTrue(self.x.has_option('sect3', 'key2', 'dev')) def test_has_option_config_fail(self): self.assertFalse(self.x.has_option('sect3', 'key2', 'scp')) def test_has_option_inheritance(self): self.assertTrue(self.x.has_option('sect1', 'key3')) def test_has_option_specificaction_fail(self): # Because config dependant self.assertFalse(self.x.has_option('sect3', 'key2')) def test_has_option_fail(self): self.assertFalse(self.x.has_option('sect3', 'key4')) def test_has_option_strict(self): self.assertTrue(self.x.has_option('sect3', 'key3', strict=True)) def test_has_option_strict_config(self): self.assertTrue(self.x.has_option('sect3', 'key2', 'dev', strict=True)) def test_has_option_strict_config_fail(self): self.assertFalse(self.x.has_option('sect3', 'key2', 'scp', strict=True)) def test_has_option_strict_inheritance(self): # Because strict self.assertFalse(self.x.has_option('sect1', 'key3', strict=True)) def test_has_option_strict_specificaction_fail(self): # Because config dependant self.assertFalse(self.x.has_option('sect3', 'key2', strict=True)) def test_has_option_strict_fail(self): self.assertFalse(self.x.has_option('sect3', 'key4', strict=True)) def test_has_option_config_ind(self): self.assertTrue(self.x.has_option('sect3', 'key3', cfg_ind=True)) def test_has_option_config_ind_inheritance(self): self.assertTrue(self.x.has_option('sect1', 'key3', cfg_ind=True)) def test_has_option_config_ind_specificaction(self): self.assertTrue(self.x.has_option('sect3', 'key2', cfg_ind=True)) def test_has_option_config_ind_fail(self): self.assertFalse(self.x.has_option('sect3', 'key4', cfg_ind=True)) def test_has_option_strict_config_ind(self): self.assertTrue(self.x.has_option('sect3', 'key3', cfg_ind=True, strict=True)) def test_has_option_strict_config_ind_inheritance(self): self.assertFalse(self.x.has_option('sect1', 'key3', cfg_ind=True, strict=True)) def test_has_option_strict_config_ind_specificaction(self): self.assertTrue(self.x.has_option('sect3', 'key2', cfg_ind=True, strict=True)) def test_has_option_strict_config_ind_fail(self): self.assertFalse(self.x.has_option('sect3', 'key4', cfg_ind=True, strict=True)) def test_options_basic(self): res = ['key1', 'key2', 'key2[dev]', 'key2[dev_plop]', 'key1[dev_plop_toto_stuff]', 'key2', 'key3', 'key049', 'key049[dev]'] self.assertEquals(self.x.options('sect2'), res) def test_options_inheritance(self): res = ['key1', 'key_int', 'key_bool1', 'key_bool2', 'key_bool3', 'key_bool4', 'key_bool5', 'key_bool6', 'key_float', 'key_list', 'key_list_int', 'key_list_bool', 'key_list_float', 'key1[dev]', 'key1', 'key2', 'key2[dev]', 'key2[dev_plop]', 'key1[dev_plop_toto]', 'key2[dev]', 'key3', 'key3[dev]', 'key3[toto]', 'key3[dev_plop]', 'key3[dev_plop_toto]', 'key1[dev_plop_toto_stuff]', 'key2', 'key3', 'key049', 'key049[dev]'] self.assertEquals(self.x.options('sect1'), res) def test_options_strict(self): res = ['key1', 'key_int', 'key_bool1', 'key_bool2', 'key_bool3', 'key_bool4', 'key_bool5', 'key_bool6', 'key_float', 'key_list', 'key_list_int', 'key_list_bool', 'key_list_float', 'key1[dev]'] self.assertEquals(self.x.options('sect1', strict=True), res) def test_options_strict_defaults(self): res = ['key1', 'key_int', 'key_bool1', 'key_bool2', 'key_bool3', 'key_bool4', 'key_bool5', 'key_bool6', 'key_float', 'key_list', 'key_list_int', 'key_list_bool', 'key_list_float', 'key1[dev]', 'key1[dev_plop_toto_stuff]', 'key2', 'key3', 'key049', 'key049[dev]'] self.assertEquals(self.x.options('sect1', strict=True, defaults=True), res) def test_options_strict_config_ind(self): res = ['key1', 'key_int', 'key_bool1', 'key_bool2', 'key_bool3', 'key_bool4', 'key_bool5', 'key_bool6', 'key_float', 'key_list', 'key_list_int', 'key_list_bool', 'key_list_float'] self.assertEquals(self.x.options('sect1', strict=True, cfg_ind=True), res) def test_options_strict_config_ind_defaults(self): res = ['key1', 'key_int', 'key_bool1', 'key_bool2', 'key_bool3', 'key_bool4', 'key_bool5', 'key_bool6', 'key_float', 'key_list', 'key_list_int', 'key_list_bool', 'key_list_float', 'key2', 'key3', 'key049'] self.assertEquals(self.x.options('sect1', strict=True, defaults=True, cfg_ind=True), res) def test_options_config_ind(self): res = ['key1', 'key_int', 'key_bool1', 'key_bool2', 'key_bool3', 'key_bool4', 'key_bool5', 'key_bool6', 'key_float', 'key_list', 'key_list_int', 'key_list_bool', 'key_list_float', 'key2', 'key3', 'key049'] self.assertEquals(self.x.options('sect1', cfg_ind=True).sort(), res.sort()) def test_items_basic(self): res = [('key1', 'val1_sect2'), ('key2', 'val2'), ('key2[dev]', 'dev2'), ('key2[dev_plop]', 'dev_plop2'), ('key1[dev_plop_toto_stuff]', 'dev_plop_toto1_default'), ('key2', 'default2'), ('key3', 'default3'), ('key049', 'DEFAULT'), ('key049[dev]', 'DEFAULT_dev')] res.sort() test = self.x.items('sect2') test.sort() self.assertEquals(test, res) def test_items_inheritance(self): res = [('key1', 'val1'), ('key_int', '1'), ('key_bool1', 'true'), ('key_bool2', 'on'), ('key_bool3', '1'), ('key_bool4', 'yes'), ('key_bool5', 'false'), ('key_bool6', 'random'), ('key_float', '1.24'), ('key_list', 'damn;dang;nabbit'), ('key_list_int', '1;7;3'), ('key_list_bool', 'true;false;true'), ('key_list_float', '0.96;1.73;6.82'), ('key1[dev]', 'dev1'), ('key1', 'val1_sect2'), ('key2', 'val2'), ('key2[dev]', 'dev2'), ('key2[dev_plop]', 'dev_plop2'), ('key1[dev_plop_toto]', 'dev_plop_toto1_sect3'), ('key2[dev]', 'dev2_sect3'), ('key3', 'val3'), ('key3[dev]', 'dev3'), ('key3[toto]', 'toto3'), ('key3[dev_plop]', 'dev_plop3'), ('key3[dev_plop_toto]', 'dev_plop_toto3'), ('key1[dev_plop_toto_stuff]', 'dev_plop_toto1_default'), ('key2', 'default2'), ('key3', 'default3'), ('key049', 'DEFAULT'), ('key049[dev]', 'DEFAULT_dev')] res.sort() test = self.x.items('sect1') test.sort() self.assertEquals(test, res) def test_items_strict_basic(self): res = [('key1', 'val1'), ('key_int', '1'), ('key_bool1', 'true'), ('key_bool2', 'on'), ('key_bool3', '1'), ('key_bool4', 'yes'), ('key_bool5', 'false'), ('key_bool6', 'random'), ('key_float', '1.24'), ('key_list', 'damn;dang;nabbit'), ('key_list_int', '1;7;3'), ('key_list_bool', 'true;false;true'), ('key_list_float', '0.96;1.73;6.82'), ('key1[dev]', 'dev1')] res.sort() test = self.x.items('sect1', strict=True) test.sort() self.assertEquals(test, res) def test_items_strict_defaults(self): res = [('key1', 'val1'), ('key_int', '1'), ('key_bool1', 'true'), ('key_bool2', 'on'), ('key_bool3', '1'), ('key_bool4', 'yes'), ('key_bool5', 'false'), ('key_bool6', 'random'), ('key_float', '1.24'), ('key_list', 'damn;dang;nabbit'), ('key_list_int', '1;7;3'), ('key_list_bool', 'true;false;true'), ('key_list_float', '0.96;1.73;6.82'), ('key1[dev]', 'dev1'), ('key1[dev_plop_toto_stuff]', 'dev_plop_toto1_default'), ('key2', 'default2'), ('key3', 'default3'), ('key049', 'DEFAULT'), ('key049[dev]', 'DEFAULT_dev')] res.sort() test = self.x.items('sect1', defaults=True, strict=True) test.sort() self.assertEquals(test, res) def test_items_all(self): res = [] for key in self.x._sections: res.append((key, SectionProxyExtended(self.x, key))) res.sort() test = self.x.items() test.sort() self.assertEquals(test, res) def test_items_strict_all(self): res = [] for key in self.x._sections: res.append((key, SectionProxyExtended(self.x, key))) res.sort() test = self.x.items(strict=True) test.sort() self.assertEquals(test, res) def test_items_vars(self): res = [('william', 'Overbeck'), ('key1', 'val1_sect2'), ('key2', 'val2'), ('key2[dev]', 'dev2'), ('key2[dev_plop]', 'dev_plop2'), ('key1[dev_plop_toto_stuff]', 'dev_plop_toto1_default'), ('key2', 'default2'), ('key3', 'default3'), ('key049', 'DEFAULT'), ('key049[dev]', 'DEFAULT_dev')] res.sort() test = self.x.items('sect2', vars={'William': 'Overbeck'}) test.sort() self.assertEquals(test, res) def test_items_vars_strict(self): res = [('william', 'Overbeck'), ('key1', 'val1_sect2'), ('key2', 'val2'), ('key2[dev]', 'dev2'), ('key2[dev_plop]', 'dev_plop2')] res.sort() test = self.x.items('sect2', vars={'William': 'Overbeck'}, strict=True) test.sort() self.assertEquals(test, res) def test_get_key_dict(self): self.assertEqual(self.x['sect2']['key2'], 'val2') def test_get_sect_dict_fail(self): self.assertRaises(KeyError, lambda: self.x['sect4']) def test_get_key_dict_fail(self): self.assertRaises(KeyError, lambda: self.x['sect2']['key42']) def test_has_section_strict(self): self.assertTrue(self.x.has_section('sect2', strict=True)) def test_has_section_strict_fail(self): self.assertFalse(self.x.has_section('sect1', strict=True)) def test_defaults(self): self.x = ExtendedConfigParser(defaults={'william': 'Overbeck'}) self.x.read('./test_cfg.ini') res = OrderedDict([('william', 'Overbeck')]) self.assertEquals(self.x.defaults(), res) def test_add_section(self): self.x.add_section('Jim Hoxworth') self.assertTrue(self.x.has_section('Jim Hoxworth')) self.assertEqual(self.x.get('Jim Hoxworth', 'key2'), 'default2') self.assertEqual(self.x['Jim Hoxworth']['key2'], 'default2') def test_read_file(self): self.x = ExtendedConfigParser() data = open('./test_cfg.ini', 'r') self.x.read_file(data) self.assertEqual(self.x.get('sect2', 'key2'), 'val2')
def test_get_father(self): self.x = ExtendedConfigParser(defaults={'key4': 'father'}) self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect1', 'key4'), 'father')
def test_get_config_section_loop_father_unspecified(self): self.x = ExtendedConfigParser(config='mem_plop', defaults={'key096': 'father'}) self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect2', 'key096', sect_first=False), 'father')
def test_get_config_section_loop_sect_unspecified(self): self.x = ExtendedConfigParser(config='dev_plop') self.x.read('./test_cfg.ini') self.assertEqual(self.x.get('sect2', 'key1', sect_first=False), 'val1_sect2')