def main(): CONF.register_cli_opt(command_opt) try: cfg_files = cfg.find_config_files(project='glance', prog='glance-registry') cfg_files.extend(cfg.find_config_files(project='glance', prog='glance-api')) cfg_files.extend(cfg.find_config_files(project='glance', prog='glance-manage')) config.parse_args(default_config_files=cfg_files, usage="%(prog)s [options] <cmd>") log.setup('glance') except RuntimeError as e: sys.exit("ERROR: %s" % e) try: if CONF.command.action.startswith('db'): return CONF.command.action_fn() else: func_kwargs = {} for k in CONF.command.action_kwargs: v = getattr(CONF.command, 'action_kwarg_' + k) if v is None: continue func_kwargs[k] = encodeutils.safe_decode(v) func_args = [encodeutils.safe_decode(arg) for arg in CONF.command.action_args] return CONF.command.action_fn(*func_args, **func_kwargs) except exception.GlanceException as e: sys.exit("ERROR: %s" % utils.exception_to_str(e))
def main(): CONF.register_cli_opt(command_opt) try: logging.register_options(CONF) cfg_files = cfg.find_config_files(project='glance', prog='glance-registry') cfg_files.extend(cfg.find_config_files(project='glance', prog='glance-api')) cfg_files.extend(cfg.find_config_files(project='glance', prog='glance-manage')) config.parse_args(default_config_files=cfg_files, usage="%(prog)s [options] <cmd>") logging.setup(CONF, 'glance') except RuntimeError as e: sys.exit("ERROR: %s" % e) try: if CONF.command.action.startswith('db'): return CONF.command.action_fn() else: func_kwargs = {} for k in CONF.command.action_kwargs: v = getattr(CONF.command, 'action_kwarg_' + k) if v is None: continue if isinstance(v, six.string_types): v = encodeutils.safe_decode(v) func_kwargs[k] = v func_args = [encodeutils.safe_decode(arg) for arg in CONF.command.action_args] return CONF.command.action_fn(*func_args, **func_kwargs) except exception.GlanceException as e: sys.exit("ERROR: %s" % utils.exception_to_str(e))
def main(): CONF.register_cli_opts([ cfg.Opt('os-username'), cfg.Opt('os-password'), cfg.Opt('os-auth-url'), cfg.Opt('os-tenant-name'), ]) try: logging.register_options(CONF) cfg_files = cfg.find_config_files(project='glance', prog='glance-api') cfg_files.extend(cfg.find_config_files(project='glance', prog='glance-search')) config.parse_args(default_config_files=cfg_files) logging.setup(CONF, 'glance') namespace = 'glance.search.index_backend' ext_manager = stevedore.extension.ExtensionManager( namespace, invoke_on_load=True) for ext in ext_manager.extensions: try: ext.obj.setup() except Exception as e: LOG.error(_LE("Failed to setup index extension " "%(ext)s: %(e)s") % {'ext': ext.name, 'e': e}) except RuntimeError as e: sys.exit("ERROR: %s" % e)
def main(): CONF.register_cli_opt(command_opt) try: logging.register_options(CONF) cfg_files = cfg.find_config_files(project='daisy', prog='daisy-registry') cfg_files.extend(cfg.find_config_files(project='daisy', prog='daisy-api')) cfg_files.extend(cfg.find_config_files(project='daisy', prog='daisy-manage')) cfg_files.extend(cfg.find_config_files(project='daisy', prog='daisy-orchestration')) config.parse_args(default_config_files=cfg_files, usage="%(prog)s [options] <cmd>") logging.setup(CONF, 'daisy') except RuntimeError as e: sys.exit("ERROR: %s" % e) try: if CONF.command.action.startswith('db'): return CONF.command.action_fn() else: func_kwargs = {} for k in CONF.command.action_kwargs: v = getattr(CONF.command, 'action_kwarg_' + k) if v is None: continue if isinstance(v, six.string_types): v = encodeutils.safe_decode(v) func_kwargs[k] = v func_args = [encodeutils.safe_decode(arg) for arg in CONF.command.action_args] return CONF.command.action_fn(*func_args, **func_kwargs) except exception.DaisyException as e: sys.exit("ERROR: %s" % utils.exception_to_str(e))
def main(): CONF.register_cli_opts([ cfg.Opt('os-username'), cfg.Opt('os-password'), cfg.Opt('os-auth-url'), cfg.Opt('os-tenant-name'), ]) try: logging.register_options(CONF) cfg_files = cfg.find_config_files(project='glance', prog='glance-api') cfg_files.extend( cfg.find_config_files(project='glance', prog='glance-search')) config.parse_args(default_config_files=cfg_files) logging.setup(CONF, 'glance') namespace = 'glance.search.index_backend' ext_manager = stevedore.extension.ExtensionManager(namespace, invoke_on_load=True) for ext in ext_manager.extensions: try: ext.obj.setup() except Exception as e: LOG.error( _LE("Failed to setup index extension " "%(ext)s: %(e)s") % { 'ext': ext.name, 'e': e }) except RuntimeError as e: sys.exit("ERROR: %s" % e)
def __init__(self, service_name=None): self.dfa_cfg = {} self._load_default_opts() args = sys.argv[1:] try: opts = [(args[i], args[i + 1]) for i in range(0, len(args), 2)] except IndexError: opts = [] cfgfile = cfg.find_config_files(service_name) for k, v in opts: if k == '--config-file': cfgfile.insert(0, v) multi_parser = cfg.MultiConfigParser() read_ok = multi_parser.read(cfgfile) if len(read_ok) != len(cfgfile): raise cfg.Error(_LE("Failed to parse config file.")) for parsed_file in multi_parser.parsed: for parsed_item in parsed_file.keys(): if parsed_item not in self.dfa_cfg: self.dfa_cfg[parsed_item] = {} for key, value in parsed_file[parsed_item].items(): self.dfa_cfg[parsed_item][key] = value[0] # Convert it to object. self._cfg = utils.Dict2Obj(self.dfa_cfg)
def main(): parser = get_parser() args = parser.parse_args() try: if args.config_file: default_config_files = [args.config_file] else: default_config_files = cfg.find_config_files('murano') if not default_config_files: murano_conf = os.path.join(os.path.dirname(__file__), os.pardir, os.pardir, 'etc', 'murano', 'murano.conf') if os.path.exists(murano_conf): default_config_files = [murano_conf] sys.argv = [sys.argv[0]] config.parse_args(default_config_files=default_config_files) except RuntimeError as e: LOG.exception(_LE("Failed to initialize murano-test-runner: %s") % e) sys.exit("ERROR: %s" % e) try: exit_code = run_tests(args) sys.exit(exit_code) except Exception as e: tb = traceback.format_exc() err_msg = _LE("Command failed: {0}\n{1}").format(e, tb) LOG.error(err_msg) sys.exit(err_msg)
def main(): """Parse options and call the appropriate class/method.""" CONF = config.new_config() CONF.register_cli_opt(category_opt) try: logging.register_options(CONF) logging.setup(CONF, "osvmexpire-manage") cfg_files = cfg.find_config_files(project='os-vm-expire') CONF(args=sys.argv[1:], project='os-vm-expire', prog='osvmexpire-manage', version=os_vm_expire.version.__version__, default_config_files=cfg_files) except RuntimeError as e: sys.exit("ERROR: %s" % e) # find sub-command and its arguments fn = CONF.category.action_fn fn_args = [arg.decode('utf-8') for arg in CONF.category.action_args] fn_kwargs = {} for k in CONF.category.action_kwargs: v = getattr(CONF.category, 'action_kwarg_' + k) if v is None: continue if isinstance(v, bytes): v = v.decode('utf-8') fn_kwargs[k] = v # call the action with the remaining arguments try: return fn(*fn_args, **fn_kwargs) except Exception as e: sys.exit("ERROR: %s" % e)
def main(): test_runner = MuranoTestRunner() try: if test_runner.args.config_file: default_config_files = [test_runner.args.config_file] else: default_config_files = cfg.find_config_files('murano') if not default_config_files: murano_conf = os.path.join(os.path.dirname(__file__), os.pardir, os.pardir, 'etc', 'murano', 'murano.conf') if os.path.exists(murano_conf): default_config_files = [murano_conf] sys.argv = [sys.argv[0]] config.parse_args(default_config_files=default_config_files) logging.setup(CONF, 'murano') except RuntimeError as e: LOG.exception(_LE("Failed to initialize murano-test-runner: %s") % e) sys.exit("ERROR: %s" % e) try: exit_code = test_runner.run_tests() sys.exit(exit_code) except Exception as e: tb = traceback.format_exc() err_msg = _LE("Command failed: {0}\n{1}").format(e, tb) LOG.error(err_msg) sys.exit(err_msg)
def __init__(self, service_name=None): self.dfa_cfg = {} self._load_default_opts() args = sys.argv[1:] try: opts = [(args[i], args[i + 1]) for i in range(0, len(args), 2)] except IndexError: opts = [] cfgfile = cfg.find_config_files(service_name) for k, v in opts: if k == '--config-file': cfgfile.append(v) multi_parser = cfg.MultiConfigParser() read_ok = multi_parser.read(cfgfile) if len(read_ok) != len(cfgfile): raise cfg.Error(_LE("Failed to parse config file.")) for parsed_file in multi_parser.parsed: for parsed_item in parsed_file.keys(): if parsed_item not in self.dfa_cfg: self.dfa_cfg[parsed_item] = {} for key, value in parsed_file[parsed_item].items(): self.dfa_cfg[parsed_item][key] = value[0] # Convert it to object. self._cfg = utils.Dict2Obj(self.dfa_cfg)
def _configure(args): config_files = [] virtual_path = os.getenv('VIRTUAL_ENV') cfg_file = '{0}.conf'.format(tvrenamer.PROJECT_NAME) # if virtualenv is active; then leverage <virtualenv>/etc # and <virtualenv>/etc/<project> if virtual_path: config_files.append(os.path.join(virtual_path, 'etc', cfg_file)) config_files.append(os.path.join(virtual_path, 'etc', tvrenamer.PROJECT_NAME, cfg_file)) config_files.extend( cfg.find_config_files(project=tvrenamer.PROJECT_NAME)) cfg.CONF(args, project=tvrenamer.PROJECT_NAME, version=tvrenamer.__version__, default_config_files=list(moves.filter(os.path.isfile, config_files))) # if no config_dir was provided then we will set it to the # path of the most specific config file found. if not cfg.CONF.config_dir and cfg.CONF.config_file: cfg.CONF.set_default('config_dir', os.path.dirname(cfg.CONF.config_file[-1]))
def main(): CONF.register_cli_opt(command_opt) if len(sys.argv) < 2: script_name = sys.argv[0] print("%s command action [<args>]" % script_name) print(_("Available commands:")) for command in COMMANDS: print(_("\t%s") % command) sys.exit(2) try: logging.register_options(CONF) cfg_files = cfg.find_config_files(project='searchlight', prog='searchlight') config.parse_args(default_config_files=cfg_files) config.set_config_defaults() logging.setup(CONF, 'searchlight') func_kwargs = {} for k in CONF.command.action_kwargs: v = getattr(CONF.command, 'action_kwarg_' + k) if v is None: continue if isinstance(v, six.string_types): v = encodeutils.safe_decode(v) func_kwargs[k] = v func_args = [ encodeutils.safe_decode(arg) for arg in CONF.command.action_args ] return CONF.command.action_fn(*func_args, **func_kwargs) except RuntimeError as e: sys.exit("ERROR: %s" % e)
def main(): import sys from heat.common import context from heat import version command_opt = cfg.SubCommandOpt('command', title='Commands', help='Show available commands', handler=add_command_parsers) CONF.register_cli_opt(command_opt) try: default_config_files = cfg.find_config_files('heat', 'heat-engine') CONF(sys.argv[1:], project='heat', prog='heat-recover', version=version.version_info.version_string(), default_config_files=default_config_files) except RuntimeError as e: sys.exit("ERROR: %s" % e) global ctxt ctxt = context.get_admin_context() CONF.command.func()
def main(): test_runner = MuranoTestRunner() try: if test_runner.args.config_file: default_config_files = [test_runner.args.config_file] else: default_config_files = cfg.find_config_files('murano') if not default_config_files: murano_conf = os.path.join(os.path.dirname(__file__), os.pardir, os.pardir, 'etc', 'murano', 'murano.conf') if os.path.exists(murano_conf): default_config_files = [murano_conf] sys.argv = [sys.argv[0]] config.parse_args(default_config_files=default_config_files) CONF.set_default('use_stderr', False) logging.setup(CONF, 'murano') except RuntimeError as e: LOG.exception("Failed to initialize murano-test-runner: %s", e) sys.exit("ERROR: %s" % e) try: exit_code = test_runner.run_tests() sys.exit(exit_code) except Exception as e: if isinstance(e, dsl_exception.MuranoPlException): tb = e.format() else: tb = traceback.format_exc() err_msg = "Command failed: {0}\n{1}".format(e, tb) LOG.error(err_msg) sys.exit(err_msg)
def _configure(args): config_files = [] virtual_path = os.getenv('VIRTUAL_ENV') cfg_file = '{0}.conf'.format(tvrenamer.PROJECT_NAME) # if virtualenv is active; then leverage <virtualenv>/etc # and <virtualenv>/etc/<project> if virtual_path: config_files.append(os.path.join(virtual_path, 'etc', cfg_file)) config_files.append( os.path.join(virtual_path, 'etc', tvrenamer.PROJECT_NAME, cfg_file)) config_files.extend(cfg.find_config_files(project=tvrenamer.PROJECT_NAME)) cfg.CONF(args, project=tvrenamer.PROJECT_NAME, version=tvrenamer.__version__, default_config_files=list( moves.filter(os.path.isfile, config_files))) # if no config_dir was provided then we will set it to the # path of the most specific config file found. if not cfg.CONF.config_dir and cfg.CONF.config_file: cfg.CONF.set_default('config_dir', os.path.dirname(cfg.CONF.config_file[-1]))
def main(): CONF.register_cli_opt(command_opt) if len(sys.argv) < 2: script_name = sys.argv[0] print("%s command action [<args>]" % script_name) print(_("Available commands:")) for command in COMMANDS: print(_("\t%s") % command) sys.exit(2) try: logging.register_options(CONF) cfg_files = cfg.find_config_files(project='searchlight', prog='searchlight') config.parse_args(default_config_files=cfg_files) config.set_config_defaults() logging.setup(CONF, 'searchlight') func_kwargs = {} for k in CONF.command.action_kwargs: v = getattr(CONF.command, 'action_kwarg_' + k) if v is None: continue if isinstance(v, six.string_types): v = encodeutils.safe_decode(v) func_kwargs[k] = v func_args = [encodeutils.safe_decode(arg) for arg in CONF.command.action_args] return CONF.command.action_fn(*func_args, **func_kwargs) except RuntimeError as e: sys.exit("ERROR: %s" % e)
def _get_config_files(): """Get the possible configuration files accepted by oslo.config This also includes the deprecated ones """ # default files conf_files = cfg.find_config_files(project='monasca', prog='monasca-notification') # deprecated config files (only used if standard config files are not there) if len(conf_files) == 0: old_conf_files = cfg.find_config_files(project='monasca', prog='notification') if len(old_conf_files) > 0: LOG.warning('Found deprecated old location "{}" ' 'of main configuration file'.format(old_conf_files)) conf_files += old_conf_files return conf_files
def init(argv, default_config_files=None, **kwargs): default_config_files = (default_config_files or cfg.find_config_files(project='remora')) cfg.CONF(argv, project='remora', version=remora.__version__, default_config_files=default_config_files, **kwargs)
def _find_config_files(prog=None): env_config_file = os.environ.get local_config_file = os.path.join(PATH, '../../', DEFAULT_CONFIG_FILE) if os.path.exists(local_config_file): return [os.path.abspath(local_config_file)] # Fallback to default load order return cfg.find_config_files(project='nebula', prog=prog)
def parse_args(argv, default_config_files=None): default_config_files = (default_config_files or cfg.find_config_files(project='watcher')) rpc.set_defaults(control_exchange='watcher') cfg.CONF(argv[1:], project='python-watcher', version=version.version_info.release_string(), default_config_files=default_config_files) rpc.init(cfg.CONF)
def main(): CONF.register_cli_opt(command_opt) if len(sys.argv) < 2: script_name = sys.argv[0] print("%s category action [<args>]" % script_name) print(_("Available categories:")) for category in CATEGORIES: print(_("\t%s") % category) sys.exit(2) try: logging.register_options(CONF) CONF.set_default(name='use_stderr', default=True, enforce_type=True) cfg_files = cfg.find_config_files(project='glance', prog='glance-registry') cfg_files.extend( cfg.find_config_files(project='glance', prog='glance-api')) cfg_files.extend( cfg.find_config_files(project='glance', prog='glance-manage')) config.parse_args(default_config_files=cfg_files) config.set_config_defaults() logging.setup(CONF, 'glance') except RuntimeError as e: sys.exit("ERROR: %s" % e) try: if CONF.command.action.startswith('db'): return CONF.command.action_fn() else: func_kwargs = {} for k in CONF.command.action_kwargs: v = getattr(CONF.command, 'action_kwarg_' + k) if v is None: continue if isinstance(v, six.string_types): v = encodeutils.safe_decode(v) func_kwargs[k] = v func_args = [ encodeutils.safe_decode(arg) for arg in CONF.command.action_args ] return CONF.command.action_fn(*func_args, **func_kwargs) except exception.GlanceException as e: sys.exit("ERROR: %s" % encodeutils.exception_to_unicode(e))
def init_tobiko_config(default_config_dirs=None, default_config_files=None, project=None, prog=None, product_name=None, version=None): if project is None: project = 'tobiko' if product_name is None: product_name = 'tobiko' if version is None: version = get_version() if default_config_dirs is None: default_config_dirs = cfg.find_config_dirs(project=project, prog=prog) if default_config_files is None: default_config_files = ( cfg.find_config_files(project=project, prog=prog) + workspace_config_files(project=project, prog=prog)) # Register configuration options conf = cfg.ConfigOpts() log.register_options(conf) register_tobiko_options(conf=conf) # Initialize Tobiko configuration object conf(args=[], validate_default_values=True, default_config_dirs=default_config_dirs, default_config_files=default_config_files) CONF.set_source('tobiko', conf) # expand and normalize log_file and log_dir names conf.config_dir = os.path.realpath(conf.find_file('.')) log_dir = conf.log_dir or conf.config_dir log_file = conf.log_file or 'tobiko.log' log_path = os.path.realpath( os.path.expanduser(os.path.join(log_dir, log_file))) conf.log_dir = os.path.dirname(log_path) conf.log_file = os.path.basename(log_path) # setup final configuration log.setup(conf=conf, product_name=product_name, version=version) setup_tobiko_config(conf=conf) LOG.debug( "Configuration setup using parameters:\n" " - product_name: %r\n" " - version: %r\n" " - default_config_dirs: %r\n" " - default_config_files: %r\n" " - log_file: %r\n", product_name, version, default_config_dirs, default_config_files, os.path.join(log_dir, log_file))
def main(): CONF.register_cli_opt(command_opt) if len(sys.argv) < 2: script_name = sys.argv[0] print("%s category action [<args>]" % script_name) print(_("Available categories:")) for category in CATEGORIES: print(_("\t%s") % category) sys.exit(2) try: logging.register_options(CONF) CONF.set_default(name='use_stderr', default=True, enforce_type=True) cfg_files = cfg.find_config_files(project='glance', prog='glance-registry') cfg_files.extend(cfg.find_config_files(project='glance', prog='glance-api')) cfg_files.extend(cfg.find_config_files(project='glance', prog='glance-manage')) config.parse_args(default_config_files=cfg_files) config.set_config_defaults() logging.setup(CONF, 'glance') except RuntimeError as e: sys.exit("ERROR: %s" % e) try: if CONF.command.action.startswith('db'): return CONF.command.action_fn() else: func_kwargs = {} for k in CONF.command.action_kwargs: v = getattr(CONF.command, 'action_kwarg_' + k) if v is None: continue if isinstance(v, six.string_types): v = encodeutils.safe_decode(v) func_kwargs[k] = v func_args = [encodeutils.safe_decode(arg) for arg in CONF.command.action_args] return CONF.command.action_fn(*func_args, **func_kwargs) except exception.GlanceException as e: sys.exit("ERROR: %s" % encodeutils.exception_to_unicode(e))
def parse_config(mapping_choices): DB_INIT = [ cfg.SubCommandOpt('db', dest='db', title='DB Options', handler=add_db_opts), cfg.StrOpt('host', default='127.0.0.1', dest='host', help='The DB host address[:port], default "127.0.0.1"'), cfg.PortOpt('port', default=9200, dest='port', help='The DB server port (default: {0})'.format( DEFAULT_ES_SERVER_PORT)), cfg.StrOpt( 'mapping', dest='select_mapping', default='', short='m', help='Specific mapping to upload. Valid choices: {0}'.format( ','.join(mapping_choices))), cfg.StrOpt('index', dest='index', short='i', default=DEFAULT_INDEX, help='The DB index (default "{0}")'.format(DEFAULT_INDEX)), cfg.BoolOpt('yes', short='y', dest='yes', default=False, help='Automatic confirmation to update mappings and ' 'number-of-replicas.'), cfg.BoolOpt('erase', short='e', dest='erase', default=False, help='Enable index deletion in case mapping update fails ' 'due to incompatible changes'), cfg.StrOpt( 'test-only', short='t', dest='test_only', default=False, help='Test the validity of the mappings, but take no action') ] driver.register_storage_opts() CONF.register_cli_opts(DB_INIT) log.register_options(CONF) default_config_files = cfg.find_config_files('freezer', 'freezer-api') CONF(args=sys.argv[1:], project='freezer-api', default_config_files=default_config_files, version=FREEZER_API_VERSION)
def parse_args(argv, default_config_files=None, default_config_dirs=None): """Load information into config and allow program arguments to override""" default_config_files = (default_config_files or cfg.find_config_files(project='RadLoggerPy')) default_config_dirs = (default_config_dirs or cfg.find_config_dirs(project='RadLoggerPy')) cfg.CONF(argv[1:], project='RadLoggerPy', version=version.version_info.release_string(), default_config_dirs=default_config_dirs, default_config_files=default_config_files)
def prepare_service(argv=[]): config.parse_args(default_config_files=cfg.find_config_files( project='eon')) cfg.set_defaults(log.log_opts, default_log_levels=[ 'amqplib=WARN', 'qpid.messaging=INFO', 'sqlalchemy=WARN', 'keystoneclient=INFO', 'stevedore=INFO', 'eventlet.wsgi.server=WARN', 'iso8601=WARN' ]) cfg.CONF(argv[1:], project='eon') log.setup('eon')
def setup_app(config): """App factory.""" # By default we expect path to oslo config file in environment variable # REFSTACK_OSLO_CONFIG (option for testing and development) # If it is empty we look up those config files # in the following directories: # ~/.${project}/ # ~/ # /etc/${project}/ # /etc/ default_config_files = ((os.getenv('REFSTACK_OSLO_CONFIG'), ) if os.getenv('REFSTACK_OSLO_CONFIG') else cfg.find_config_files('refstack')) CONF('', project='refstack', default_config_files=default_config_files) log.setup(CONF, 'refstack') CONF.log_opt_values(LOG, logging.DEBUG) template_path = CONF.api.template_path % {'project_root': PROJECT_ROOT} static_root = CONF.api.static_root % {'project_root': PROJECT_ROOT} app_conf = dict(config.app) app = pecan.make_app( app_conf.pop('root'), debug=CONF.api.app_dev_mode, static_root=static_root, template_path=template_path, hooks=[ JWTAuthHook(), JSONErrorHook(), CORSHook(), pecan.hooks.RequestViewerHook( {'items': ['status', 'method', 'controller', 'path', 'body']}, headers=False, writer=WritableLogger(LOG, logging.DEBUG) ) ] ) beaker_conf = { 'session.key': 'refstack', 'session.type': 'ext:database', 'session.url': CONF.database.connection, 'session.timeout': 604800, 'session.validate_key': api_utils.get_token(), 'session.sa.pool_recycle': 600 } app = SessionMiddleware(app, beaker_conf) if CONF.api.app_dev_mode: LOG.debug('\n\n <<< Refstack UI is available at %s >>>\n\n', CONF.ui_url) return app
def main(): try: logging.register_options(CONF) cfg_files = cfg.find_config_files(project='sios', prog='sios-api') cfg_files.extend(cfg.find_config_files(project='sios', prog='sios-search')) config.parse_args(default_config_files=cfg_files) logging.setup(CONF, 'sios') namespace = 'sios.search.index_backend' ext_manager = stevedore.extension.ExtensionManager( namespace, invoke_on_load=True) for ext in ext_manager.extensions: try: ext.obj.setup() except Exception as e: LOG.error(_LE("Failed to setup index extension " "%(ext)s: %(e)s") % {'ext': ext.name, 'e': e}) except RuntimeError as e: sys.exit("ERROR: %s" % e)
def main(): try: CONF.register_cli_opt(command_opt) default_config_files = cfg.find_config_files('senlin', 'senlin-manage') config.parse_args(sys.argv, 'senlin-manage', default_config_files) logging.setup(CONF, 'senlin-manage') except RuntimeError as e: sys.exit("ERROR: %s" % e) try: CONF.command.func() except Exception as e: sys.exit("ERROR: %s" % e)
def setup_app(config): """App factory.""" # By default we expect path to oslo config file in environment variable # REFSTACK_OSLO_CONFIG (option for testing and development) # If it is empty we look up those config files # in the following directories: # ~/.${project}/ # ~/ # /etc/${project}/ # /etc/ default_config_files = ((os.getenv('REFSTACK_OSLO_CONFIG'), ) if os.getenv('REFSTACK_OSLO_CONFIG') else cfg.find_config_files('refstack')) CONF('', project='refstack', default_config_files=default_config_files) log.setup(CONF, 'refstack') CONF.log_opt_values(LOG, logging.DEBUG) template_path = CONF.api.template_path % {'project_root': PROJECT_ROOT} static_root = CONF.api.static_root % {'project_root': PROJECT_ROOT} app_conf = dict(config.app) app = pecan.make_app( app_conf.pop('root'), debug=CONF.api.app_dev_mode, static_root=static_root, template_path=template_path, hooks=[JSONErrorHook(), CORSHook(), pecan.hooks.RequestViewerHook( {'items': ['status', 'method', 'controller', 'path', 'body']}, headers=False, writer=loggers.WritableLogger(LOG, logging.DEBUG) )] ) beaker_conf = { 'session.key': 'refstack', 'session.type': 'ext:database', 'session.url': CONF.database.connection, 'session.timeout': 604800, 'session.validate_key': api_utils.get_token(), 'session.sa.pool_recycle': 600 } app = SessionMiddleware(app, beaker_conf) if CONF.api.app_dev_mode: LOG.debug('\n\n <<< Refstack UI is available at %s >>>\n\n', CONF.ui_url) return app
def parse_args(args=[]): CONF.register_opts(_OPTS) CONF.register_cli_opts(_OPTS) # grp = cfg.OptGroup('jenkins', 'Jenkins configuration') # CONF.register_group(grp) # CONF.register_opts(_JENKINS, 'jenkins') log.register_options(CONF) default_config_files = cfg.find_config_files('catena', 'api') CONF(args=args, project='catena', default_config_files=default_config_files, version=CATENA_VERSION) assert len(CONF.get('encryption_key')) >= 4, \ 'encryption_key must be at least 4 characters long'
def configure(): """Register configuration.""" CONF.register_cli_opts(build_os_options()) CONF.register_opts(_COMMON) monitors_grp = cfg.OptGroup('monitoring', title='Monitoring', help='Monitoring Driver/plugin to be used to ' 'monitor compute nodes') CONF.register_group(monitors_grp) CONF.register_opts(_MONITORS, group='monitoring') fencers_grp = cfg.OptGroup('fencer', title='fencer Options', help='fencer Driver/plugin to be used to ' 'fence compute nodes') CONF.register_group(fencers_grp) CONF.register_opts(_FENCER, group='fencer') # Evacuation Section :) evacuators_grp = cfg.OptGroup('evacuation', title='Evacuation Options', help='Evacuation Driver/plugin opts to be ' 'used to Evacuate compute nodes') CONF.register_group(evacuators_grp) CONF.register_opts(_EVACUATION, group='evacuation') # Notification Section :) notifiers_grp = cfg.OptGroup('notifiers', title='Notification Options', help='Notification Driver/plugin opts to be ' 'used to Notify admins/users if failure' ' happens') CONF.register_group(notifiers_grp) CONF.register_opts(_NOTIFIERS, group='notifiers') # Keystone Auth keystone_grp = cfg.OptGroup('keystone_authtoken', title='Keystone Auth Options', help='OpenStack Credentials to call the nova ' 'APIs to evacuate ') CONF.register_group(keystone_grp) CONF.register_opts(_KEYSTONE_AUTH_TOKEN, group='keystone_authtoken') default_conf = cfg.find_config_files('freezer', 'freezer-dr', '.conf') log.register_options(CONF) CONF(args=sys.argv[1:], project='freezer', default_config_files=default_conf, version=FREEZER_DR_VERSION)
def configure(): """Register configuration.""" CONF.register_cli_opts(build_os_options()) CONF.register_opts(_COMMON) monitors_grp = cfg.OptGroup('monitoring', title='Monitoring', help='Monitoring Driver/plugin to be used to ' 'monitor compute nodes') CONF.register_group(monitors_grp) CONF.register_opts(_MONITORS, group='monitoring') fencers_grp = cfg.OptGroup('fencer', title='fencer Options', help='fencer Driver/plugin to be used to ' 'fence compute nodes') CONF.register_group(fencers_grp) CONF.register_opts(_FENCER, group='fencer') # Evacuation Section :) evacuators_grp = cfg.OptGroup('evacuation', title='Evacuation Options', help='Evacuation Driver/plugin opts to be ' 'used to Evacuate compute nodes') CONF.register_group(evacuators_grp) CONF.register_opts(_EVACUATION, group='evacuation') # Notification Section :) notifiers_grp = cfg.OptGroup('notifiers', title='Notification Options', help='Notification Driver/plugin opts to be ' 'used to Notify admins/users if failure ' 'happens') CONF.register_group(notifiers_grp) CONF.register_opts(_NOTIFIERS, group='notifiers') # Keystone Auth keystone_grp = cfg.OptGroup('keystone_authtoken', title='Keystone Auth Options', help='Openstack Credentials to call the nova ' 'APIs to evacuate ') CONF.register_group(keystone_grp) CONF.register_opts(_KEYSTONE_AUTH_TOKEN, group='keystone_authtoken') default_conf = cfg.find_config_files('freezer', 'freezer-dr', '.conf') log.register_options(CONF) CONF(args=sys.argv[1:], project='freezer', default_config_files=default_conf, version=FREEZER_DR_VERSION)
def parse_args(args=[]): CONF.register_cli_opts(api_common_opts()) driver.register_storage_opts() # register paste configuration paste_grp = cfg.OptGroup('paste_deploy', 'Paste Configuration') CONF.register_group(paste_grp) CONF.register_opts(paste_deploy, group=paste_grp) log.register_options(CONF) policy.Enforcer(CONF) default_config_files = cfg.find_config_files('freezer', 'freezer-api') CONF(args=args, project='freezer-api', default_config_files=default_config_files, version=FREEZER_API_VERSION)
def main(): try: logging.register_options(CONF) cfg_files = cfg.find_config_files(project='rebac', prog='rebac-api') cfg_files.extend( cfg.find_config_files(project='rebac', prog='rebac-search')) config.parse_args(default_config_files=cfg_files) logging.setup(CONF, 'rebac') namespace = 'rebac.search.index_backend' ext_manager = stevedore.extension.ExtensionManager(namespace, invoke_on_load=True) for ext in ext_manager.extensions: try: ext.obj.setup() except Exception as e: LOG.error( _LE("Failed to setup index extension " "%(ext)s: %(e)s") % { 'ext': ext.name, 'e': e }) except RuntimeError as e: sys.exit("ERROR: %s" % e)
def parse_args(): CONF.register_cli_opts(api_common_opts()) driver.register_elk_opts() # register paste configuration paste_grp = cfg.OptGroup('paste_deploy', 'Paste Configuration') CONF.register_group(paste_grp) CONF.register_opts(paste_deploy, group=paste_grp) log.register_options(CONF) default_config_files = cfg.find_config_files('freezer', 'freezer-api') CONF(args=sys.argv[1:], project='freezer-api', default_config_files=default_config_files, version=FREEZER_API_VERSION )
def main(): log.register_options(CONF) log.setup(CONF, "heat-manage") CONF.register_cli_opt(command_opt) try: default_config_files = cfg.find_config_files('heat', 'heat-engine') CONF(sys.argv[1:], project='heat', prog='heat-manage', version=version.version_info.version_string(), default_config_files=default_config_files) except RuntimeError as e: sys.exit("ERROR: %s" % e) try: CONF.command.func() except Exception as e: sys.exit("ERROR: %s" % e)
def parse_args(choices): default_conf = cfg.find_config_files('freezer', 'scheduler', '.conf') CONF.register_cli_opts(get_common_opts()) CONF.register_cli_opts(build_os_options()) log.register_options(CONF) positional = [ cfg.StrOpt('action', choices=choices, help='{0}'.format(choices), positional=True), ] CONF.register_cli_opts(positional) CONF(args=sys.argv[1:], project='freezer-scheduler', default_config_files=default_conf, version=FREEZER_VERSION)
def _get_deprecated_config_file(): """Get deprecated config file. Responsible for keeping backward compatibility with old name of the configuration file i.e. api-config.conf. New name is => api.conf as prog=api. Note: Old configuration file name did not follow a convention oslo_config expects. """ old_files = cfg.find_config_files(project='monasca', prog='api-config') if old_files is not None and len(old_files) > 0: LOG.warning('Detected old location "/etc/monasca/api-config.conf" ' 'of main configuration file') return old_files[0]
def parse_config(): DB_INIT = [ cfg.SubCommandOpt('db', dest='db', title='DB Options', handler=add_db_opts) ] # register database backend drivers config.register_db_drivers_opt() # register database cli options CONF.register_cli_opts(DB_INIT) # register logging opts log.register_options(CONF) default_config_files = cfg.find_config_files('freezer', 'freezer-api') CONF(args=sys.argv[1:], project='freezer-api', default_config_files=default_config_files, version=FREEZER_API_VERSION)
def parse_args(choices): default_conf = cfg.find_config_files('freezer', 'scheduler', '.conf') CONF.register_cli_opts(get_common_opts()) CONF.register_cli_opts(build_os_options()) log.register_options(CONF) positional = [ cfg.StrOpt('action', choices=choices, help='{0}'.format(choices), positional=True), ] CONF.register_cli_opts(positional) CONF(args=sys.argv[1:], project='freezer-scheduler', default_config_files=default_conf, version=FREEZER_VERSION )
def main(): CONF.register_cli_opt(command_opt) try: default_config_files = cfg.find_config_files('murano', 'murano') CONF(sys.argv[1:], project='murano', prog='murano-manage', version=version.version_string, default_config_files=default_config_files) except RuntimeError as e: LOG.error(_LE("failed to initialize murano-manage: %s") % e) sys.exit("ERROR: %s" % e) try: CONF.command.func() except Exception as e: tb = traceback.format_exc() err_msg = _LE("murano-manage command failed: {0}\n{1}").format(e, tb) LOG.error(err_msg) sys.exit(err_msg)
def load_config(conf=conf.CONF, config_file=None): project = 'vim-manager' default_config_files = cfg.find_config_files(project=project) extra_defaults = [] if config_file is None: config_file = 'etc/%(project)s/%(project)s.conf' % dict( project=project) if os.path.exists(config_file): extra_defaults.append(config_file) else: extra_defaults.append(config_file) # We don't really use the CLI parsing so we don't shadow the flask commands conf([], project=project, prog=project, version=version.version_info.release_string(), default_config_files=default_config_files + extra_defaults) return conf
def upload_config(self): try: stream = flask.request.stream file_path = cfg.find_config_files(project=CONF.project, prog=CONF.prog)[0] flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC # mode 00600 mode = stat.S_IRUSR | stat.S_IWUSR with os.fdopen(os.open(file_path, flags, mode), 'wb') as cfg_file: b = stream.read(BUFFER) while b: cfg_file.write(b) b = stream.read(BUFFER) CONF.mutate_config_files() except Exception as e: LOG.error("Unable to update amphora-agent configuration: " "{}".format(str(e))) return webob.Response(json=dict( message="Unable to update amphora-agent configuration.", details=str(e)), status=500) return webob.Response(json={'message': 'OK'}, status=202)
def main(): """Parse options and call the appropriate class/method.""" CONF = config.new_config() CONF.register_cli_opt(category_opt) try: logging.register_options(CONF) logging.setup(CONF, "barbican-manage") cfg_files = cfg.find_config_files(project='barbican') CONF(args=sys.argv[1:], project='barbican', prog='barbican-manage', version=barbican.version.__version__, default_config_files=cfg_files) except RuntimeError as e: sys.exit("ERROR: %s" % e) # find sub-command and its arguments fn = CONF.category.action_fn fn_args = [arg.decode('utf-8') for arg in CONF.category.action_args] fn_kwargs = {} for k in CONF.category.action_kwargs: v = getattr(CONF.category, 'action_kwarg_' + k) if v is None: continue if isinstance(v, six.string_types): v = v.decode('utf-8') fn_kwargs[k] = v # call the action with the remaining arguments try: ret = fn(*fn_args, **fn_kwargs) return(ret) except Exception as e: sys.exit("ERROR: %s" % e)
def setup_app(config): """App factory.""" # By default we expect path to oslo config file in environment variable # REFSTACK_OSLO_CONFIG (option for testing and development) # If it is empty we look up those config files # in the following directories: # ~/.${project}/ # ~/ # /etc/${project}/ # /etc/ default_config_files = ((os.getenv('REFSTACK_OSLO_CONFIG'), ) if os.getenv('REFSTACK_OSLO_CONFIG') else cfg.find_config_files('refstack')) CONF('', project='refstack', default_config_files=default_config_files) log.setup(CONF, 'refstack') CONF.log_opt_values(LOG, logging.DEBUG) template_path = CONF.api.template_path % {'project_root': PROJECT_ROOT} static_root = CONF.api.static_root % {'project_root': PROJECT_ROOT} app_conf = dict(config.app) app = pecan.make_app( app_conf.pop('root'), debug=CONF.api.app_dev_mode, static_root=static_root, template_path=template_path, hooks=[JSONErrorHook(), CORSHook(), pecan.hooks.RequestViewerHook( {'items': ['status', 'method', 'controller', 'path', 'body']}, headers=False, writer=loggers.WritableLogger(LOG, logging.DEBUG) )] ) return app
def parse_cache_args(args=None): config_files = cfg.find_config_files(project='searchlight', prog='searchlight-cache') parse_args(args=args, default_config_files=config_files)
def parse_cache_args(args=None): config_files = cfg.find_config_files(project='glance', prog='glance-cache') parse_args(args=args, default_config_files=config_files)
def parse_cache_args(args=None): config_files = cfg.find_config_files(project='umbrella', prog='umbrella-cache') parse_args(args=args, default_config_files=config_files)
# /etc/myapp.conf # # To test which of these take precedence, put a config file # in each of these places and record which values get used # as you delete one config at a time. from __future__ import print_function from oslo_config import cfg import sys opt_group1 = cfg.OptGroup(name='simple',title='A Simple Example') simple_opts = [ cfg.BoolOpt('disable',default=False,help=('True enables, False disables')), cfg.StrOpt('strvar',default='Empty',help=('String help')), cfg.ListOpt('listvar',default=None,help=('List help')), cfg.DictOpt('dictvar',default=None,help=('Dictionary help')), cfg.IntOpt('intvar',default=0,help=('Integer help')), cfg.FloatOpt('floatvar',default=0.0,help=('Float help'))] CONF = cfg.CONF CONF.register_group(opt_group1) CONF.register_opts(simple_opts,opt_group1) if __name__ == '__main__': # DEFAULTS: oslo_config.cfg.find_config_files(project=None, prog=None, extension='.conf') config_list = cfg.find_config_files(project='foo') if (len(config_list) == 0): print('empty list') sys.exit(1) print('we chose this config: ' + str(config_list)) CONF(default_config_files=config_list) print(CONF.simple.strvar)
def parse_config(mapping_choices): DB_INIT = [ cfg.SubCommandOpt('db', dest='db', title='DB Options', handler=add_db_opts ), cfg.StrOpt('host', default='127.0.0.1', dest='host', help='The DB host address[:port], default "127.0.0.1"'), cfg.PortOpt('port', default=9200, dest='port', help='The DB server port (default: {0})'. format(DEFAULT_ES_SERVER_PORT) ), cfg.StrOpt('mapping', dest='select_mapping', default='', short='m', help='Specific mapping to upload. Valid choices: {0}' .format(','.join(mapping_choices))), cfg.StrOpt('index', dest='index', short='i', default=DEFAULT_INDEX, help='The DB index (default "{0}")'.format(DEFAULT_INDEX) ), cfg.BoolOpt('yes', short='y', dest='yes', default=False, help='Automatic confirmation to update mappings and ' 'number-of-replicas.'), cfg.BoolOpt('erase', short='e', dest='erase', default=False, help='Enable index deletion in case mapping update fails ' 'due to incompatible changes' ), cfg.StrOpt('test-only', short='t', dest='test_only', default=False, help='Test the validity of the mappings, but take no action' ) ] opt_group = cfg.OptGroup(name='storage', title='Freezer Storage Engine') CONF.register_group(opt_group) CONF.register_opts(driver.get_elk_opts(), group=opt_group) CONF.register_cli_opts(DB_INIT) log.register_options(CONF) default_config_files = cfg.find_config_files('freezer', 'freezer-api') CONF(args=sys.argv[1:], project='freezer-api', default_config_files=default_config_files, version=FREEZER_API_VERSION )
def parse_cache_args(args=None): config_files = cfg.find_config_files(project='xmonitor', prog='xmonitor-cache') parse_args(args=args, default_config_files=config_files)
:param prog: the program name, defaulting to the basename of sys.argv[0] :param extension: the type of the config file We default to two config files: [${project}.conf, ${prog}.conf] And we look for those config files in the following directories:: ~/.${project}/ ~/ /etc/${project}/ /etc/ We return an absolute path for (at most) one of each the default config files, for the topmost directory it exists in. For example, if project=foo, prog=bar and /etc/foo/foo.conf, /etc/bar.conf and ~/.foo/bar.conf all exist, then we return ['/etc/foo/foo.conf', '~/.foo/bar.conf'] ''' default_config_files = cfg.find_config_files('service') # CONF(default_config_files=default_config_files) #这样是找不到的 # 当前文件夹下的service.conf文件 CONF(default_config_files=['service.conf']) print CONF.roll_back print CONF.collect_worker print CONF.host print CONF.Auth.auth_url print cfg.CONF.Auth.auth_url