def _load_rules(path):
full_path = CONF.find_file(path)
if not full_path:
raise cfg.ConfigFilesNotFoundError([path])
with open(full_path) as fd:
return json.load(fd)
def load_paste_app(app_name):
"""Builds and returns a WSGI app from a paste config file.
:param app_name: Name of the application to load
:raises ConfigFilesNotFoundError when config file cannot be located
:raises RuntimeError when application cannot be loaded from config file
"""
config_path = cfg.CONF.find_file(cfg.CONF.api_paste_config)
if not config_path:
raise cfg.ConfigFilesNotFoundError(
config_files=[cfg.CONF.api_paste_config])
config_path = os.path.abspath(config_path)
LOG.info(_("Config paste file: %s"), config_path)
try:
app = deploy.loadapp("config:%s" % config_path, name=app_name)
except (LookupError, ImportError):
msg = (_("Unable to load %(app_name)s from "
"configuration file %(config_path)s.") % {
'app_name': app_name,
'config_path': config_path
})
LOG.exception(msg)
raise RuntimeError(msg)
return app
def find_paste_config():
config_path = cfg.CONF.find_file(cfg.CONF.api_paste_config)
if not config_path:
raise cfg.ConfigFilesNotFoundError(
config_files=[cfg.CONF.api_paste_config])
config_path = os.path.abspath(config_path)
LOG.info(_("Config paste file: %s"), config_path)
return config_path
def _load_rates(path, period_sec, node_count):
full_path = CONF.find_file(path)
if not full_path:
raise cfg.ConfigFilesNotFoundError([path or '<Empty>'])
with open(full_path) as fd:
document = json.load(fd)
return [Rate(rate_doc, period_sec, node_count)
for rate_doc in document]
def load_app():
# Build the WSGI app
cfg_file = None
cfg_path = cfg.CONF.api_paste_config
if not os.path.isabs(cfg_path):
cfg_file = CONF.find_file(cfg_path)
elif os.path.exists(cfg_path):
cfg_file = cfg_path
if not cfg_file:
raise cfg.ConfigFilesNotFoundError([cfg.CONF.api_paste_config])
LOG.info("Full WSGI config used: %s" % cfg_file)
return deploy.loadapp("config:" + cfg_file)
def __new__(cls, cell_state_cls=None, cells_config=_unset):
if cls is not CellStateManager:
return super(CellStateManager, cls).__new__(cls)
if cells_config is _unset:
cells_config = CONF.cells.cells_config
if cells_config:
config_path = CONF.find_file(cells_config)
if not config_path:
raise cfg.ConfigFilesNotFoundError(config_files=[cells_config])
return CellStateManagerFile(cell_state_cls, config_path)
return CellStateManagerDB(cell_state_cls)
def _get_policy_path(self):
"""Locate the policy json data file.
:param policy_file: Custom policy file to locate.
:returns: The policy path
:raises: ConfigFilesNotFoundError if the file couldn't
be located.
"""
policy_file = CONF.find_file(self.policy_file)
if policy_file:
return policy_file
raise cfg.ConfigFilesNotFoundError((self.policy_file, ))
def _get_policy_path(self, path):
"""Locate the policy json data file/path.
:param path: It's value can be a full path or related path. When
full path specified, this function just returns the full
path. When related path specified, this function will
search configuration directories to find one that exists.
:returns: The policy path
:raises: ConfigFilesNotFoundError if the file/path couldn't
be located.
"""
policy_path = CONF.find_file(path)
if policy_path:
return policy_path
raise cfg.ConfigFilesNotFoundError((path,))
def __init__(self, cell_state_cls=None):
cells_config = CONF.cells.cells_config
self.cells_config_path = CONF.find_file(cells_config)
if not self.cells_config_path:
raise cfg.ConfigFilesNotFoundError(config_files=[cells_config])
super(CellStateManagerFile, self).__init__(cell_state_cls)
class CliUtilsTestCase(test.TestCase):
def setUp(self):
super(CliUtilsTestCase, self).setUp()
self.categories = {
"deployment": deployment.DeploymentCommands,
"info": info.InfoCommands,
"show": show.ShowCommands,
"task": task.TaskCommands,
"use": use.UseCommands,
"verify": verify.VerifyCommands
}
def tearDown(self):
self._unregister_opts()
super(CliUtilsTestCase, self).tearDown()
def test_pretty_float_formatter_rounding(self):
test_table_rows = {"test_header": 6.56565}
self.__dict__.update(**test_table_rows)
formatter = cliutils.pretty_float_formatter("test_header", 3)
return_value = formatter(self)
self.assertEqual(return_value, 6.566)
def test_pretty_float_formatter_nonrounding(self):
test_table_rows = {"test_header": 6.56565}
self.__dict__.update(**test_table_rows)
formatter = cliutils.pretty_float_formatter("test_header")
return_value = formatter(self)
self.assertEqual(return_value, 6.56565)
def test_pretty_float_formatter_none_value(self):
test_table_rows = {"test_header": None}
self.__dict__.update(**test_table_rows)
formatter = cliutils.pretty_float_formatter("test_header")
return_value = formatter(self)
self.assertEqual(return_value, "n/a")
def test__methods_of_with_class(self):
class fake_class(object):
def public(self):
pass
def _private(self):
pass
result = cliutils._methods_of(fake_class)
self.assertEqual(1, len(result))
self.assertEqual("public", result[0][0])
def test__methods_of_with_object(self):
class fake_class(object):
def public(self):
pass
def _private(self):
pass
mock_obj = fake_class()
result = cliutils._methods_of(mock_obj)
self.assertEqual(1, len(result))
self.assertEqual("public", result[0][0])
def test__methods_of_empty_result(self):
class fake_class(object):
def _private(self):
pass
def _private2(self):
pass
mock_obj = fake_class()
result = cliutils._methods_of(mock_obj)
self.assertEqual(result, [])
def _unregister_opts(self):
CONF.reset()
category_opt = cfg.SubCommandOpt("category",
title="Command categories",
help="Available categories")
CONF.unregister_opt(category_opt)
@mock.patch("rally.cmd.cliutils.CONF",
config_file=None,
side_effect=cfg.ConfigFilesNotFoundError("config_file"))
def test_run_fails(self, mock_cmd_cliutils_conf):
ret = cliutils.run(["rally", "show", "flavors"], self.categories)
self.assertEqual(ret, 2)
def test_run_version(self):
ret = cliutils.run(["rally", "version"], self.categories)
self.assertEqual(ret, 0)
def test_run_bash_completion(self):
ret = cliutils.run(["rally", "bash-completion"], self.categories)
self.assertEqual(ret, 0)
def test_run_bash_completion_with_query_category(self):
ret = cliutils.run(["rally", "bash-completion", "info"],
self.categories)
self.assertEqual(ret, 0)
def test_run_show(self):
ret = cliutils.run(["rally", "show", "keypairs"], self.categories)
self.assertEqual(ret, 1)
@mock.patch("rally.openstack.common.cliutils.validate_args",
side_effect=exceptions.MissingArgs("missing"))
def test_run_show_fails(self, mock_validate_args):
ret = cliutils.run(["rally", "show", "keypairs"], self.categories)
self.assertTrue(mock_validate_args.called)
self.assertEqual(ret, 1)
def test_run_failed_to_open_file(self):
class FailuresCommands(object):
def failed_to_open_file(self):
raise IOError("No such file")
ret = cliutils.run(["rally", "failure", "failed_to_open_file"],
{"failure": FailuresCommands})
self.assertEqual(1, ret)
