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 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 _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
