def main(self, argv):
parsed = self.parse_args(argv)
if parsed == 0:
return 0
api_version, args = parsed
# Short-circuit and deal with help command right away.
if args.func == self.do_help:
self.do_help(args)
return 0
elif args.func == self.do_bash_completion:
self.do_bash_completion(args)
return 0
if not ((self.auth_plugin.opts.get('token')
or self.auth_plugin.opts.get('auth_token'))
and self.auth_plugin.opts['endpoint']):
if not self.auth_plugin.opts['username']:
raise exc.CommandError("You must provide a username via "
"either --os-username or via "
"env[OS_USERNAME]")
if not self.auth_plugin.opts['password']:
raise exc.CommandError("You must provide a password via "
"either --os-password or via "
"env[OS_PASSWORD]")
if self.no_project_and_domain_set(args):
# steer users towards Keystone V3 API
raise exc.CommandError("You must provide a project_id via "
"either --os-project-id or via "
"env[OS_PROJECT_ID] and "
"a domain_name via either "
"--os-user-domain-name or via "
"env[OS_USER_DOMAIN_NAME] or "
"a domain_id via either "
"--os-user-domain-id or via "
"env[OS_USER_DOMAIN_ID]")
if not self.auth_plugin.opts['auth_url']:
raise exc.CommandError("You must provide an auth url via "
"either --os-auth-url or via "
"env[OS_AUTH_URL]")
client_kwargs = vars(args)
client_kwargs.update(self.auth_plugin.opts)
client_kwargs['auth_plugin'] = self.auth_plugin
client = ckclient.get_client(api_version, **client_kwargs)
# call whatever callback was selected
try:
args.func(client, args)
except exc.HTTPUnauthorized:
raise exc.CommandError("Invalid OpenStack Identity credentials.")
def do_rating_metric_rule_set_delete(cc, args={}):
"""Delete a metric rule set."""
try:
cc.gnocchi.metric_rule_sets.delete(metric_rule_set_id=args.id)
except exc.HTTPNotFound:
raise exc.CommandError('Metric rule set not found: %s' %
args.counter_name)
def do_rating_metric_rule_list(cc, args={}):
"""List metric rules."""
if args.metric_rule_set_id is None:
raise exc.CommandError("Provide metric-rule-set-id")
try:
metric_rules = cc.gnocchi.metric_rules.list(
metric_rule_set_id=args.metric_rule_set_id)
except exc.HTTPNotFound:
raise exc.CommandError('Metric rule not found: %s' % args.counter_name)
else:
field_labels = ['Id', 'Cost', 'Type', 'Metric rule set id',
'Valid Since', 'Valid Until', 'Providers']
fields = ['id', 'cost', 'type', 'metric_rule_set_id',
'valid_since', 'valid_until', 'providers']
utils.print_list(metric_rules, fields, field_labels,
sortby=0)
def _discover_auth_versions(session, auth_url):
# discover the API versions the server is supporting based on the
# given URL
v2_auth_url = None
v3_auth_url = None
try:
ks_discover = discover.Discover(session=session, auth_url=auth_url)
v2_auth_url = ks_discover.url_for('2.0')
v3_auth_url = ks_discover.url_for('3.0')
except ks_exc.DiscoveryFailure:
raise
except exceptions.ClientException:
# Identity service may not support discovery. In that case,
# try to determine version from auth_url
url_parts = urlparse.urlparse(auth_url)
(scheme, netloc, path, params, query, fragment) = url_parts
path = path.lower()
if path.startswith('/v3'):
v3_auth_url = auth_url
elif path.startswith('/v2'):
v2_auth_url = auth_url
else:
raise exc.CommandError('Unable to determine the Keystone '
'version to authenticate with '
'using the given auth_url.')
return v2_auth_url, v3_auth_url
def do_rating_mapping_update(cc, args={}):
"""Update a metadata rule."""
arg_to_field_mapping = {
'id': 'id',
'cost': 'cost',
'value': 'value',
'display_value': 'display_value',
'type': 'type',
'valid_since': 'valid_since',
'valid_until': 'valid_until',
'providers': 'providers',
}
try:
metadata_rule = cc.gnocchi.metadata_rules.get(id=args.id)
except exc.HTTPNotFound:
raise exc.CommandError('Metadata rule not found: %s' %
args.counter_name)
for k, v in vars(args).items():
if k in arg_to_field_mapping:
if v is not None:
if k == 'valid_since':
setattr(metadata_rule, k, None)
else:
setattr(metadata_rule, k, v)
cc.gnocchi.metadata_rules.update(**metadata_rule.dirty_fields)
def do_metric_definition_update(cc, args={}):
"""Update a metric definition."""
arg_to_field_mapping = {
'gnocchi_metric': 'gnocchi_metric',
'name': 'name',
'description': 'description',
'function': 'function',
'reaggregation': 'reaggregation',
'show_measures': 'show_measures',
'show_cost': 'show_cost',
'unit': 'unit',
}
try:
mapping = cc.metrics.mappings.get(definition_id=args.id)
except exc.HTTPNotFound:
raise exc.CommandError('Metric definition not found: %s' %
args.counter_name)
for k, v in vars(args).items():
if k in arg_to_field_mapping:
if v is not None:
if k == "show_measures" or k == "show_cost":
setattr(mapping, k, "true" in v.lower() or "1" in v)
else:
setattr(mapping, k, v)
utils.print_dict(
cc.metrics.mappings.update(**mapping.dirty_fields).to_dict())
def do_rating_metadata_rule_set_get(cc, args={}):
"""Get a metadata rule set."""
try:
metadata_rule_set = cc.gnocchi.metadata_rule_sets.get(
metadata_rule_set_id=args.id)
except exc.HTTPNotFound:
raise exc.CommandError('Metadata rule set not found: %s' % args.id)
utils.print_dict(metadata_rule_set.to_dict())
def do_rating_threshold_rule_get(cc, args={}):
"""Get a threshold rule."""
try:
threshold_rule = cc.gnocchi.threshold_rules.get(
threshold_rule_id=args.id)
except exc.HTTPNotFound:
raise exc.CommandError('Threshold rule not found: %s' % args.id)
utils.print_dict(threshold_rule.to_dict())
def do_help(self, args):
"""Display help about this program or one of its subcommands."""
if getattr(args, 'command', None):
if args.command in self.subcommands:
self.subcommands[args.command].print_help()
else:
raise exc.CommandError("'%s' is not a valid subcommand" %
args.command)
else:
self.parser.print_help()
def args_array_to_dict(kwargs, key_to_convert):
values_to_convert = kwargs.get(key_to_convert)
if values_to_convert:
try:
kwargs[key_to_convert] = dict(v.split("=", 1)
for v in values_to_convert)
except ValueError:
raise exc.CommandError(
'%s must be a list of key=value not "%s"' % (
key_to_convert, values_to_convert))
return kwargs
def do_rating_metadata_rule_set_list(cc, args={}):
"""List metadata rule sets."""
try:
created_metadata_rule_set = cc.gnocchi.metadata_rule_sets.list(
metric_rule_set_id=args.metric_rule_set_id)
except exc.HTTPNotFound:
raise exc.CommandError('Metadata rule sets not found: %s' %
args.counter_name)
else:
field_labels = ['Id', 'Name', 'Metadata rule set id']
fields = ['id', 'name', 'metric_rule_set_id']
utils.print_list(created_metadata_rule_set, fields, field_labels,
sortby=0)
def do_rating_metric_rule_set_list(cc, args={}):
"""List metric rule sets."""
try:
metric_rule_sets = cc.gnocchi.metric_rule_sets.list()
except exc.HTTPNotFound:
raise exc.CommandError('Metric rule sets not found: %s' %
args.counter_name)
else:
field_labels = ['Gnocchi Metric', 'Aggregation Function',
'Gnocchi Unit', 'Billing Unit', 'Id']
fields = ['gnocchi_metric', 'aggregation_function', 'gnocchi_unit',
'billing_unit', 'id']
utils.print_list(metric_rule_sets, fields, field_labels,
sortby=0)
def do_chart_definition_update(cc, args={}):
"""Update a chart definition."""
arg_to_field_mapping = {
'gnocchi_metric': 'gnocchi_metric',
'name': 'name',
'description': 'description',
'granularities': 'granularities',
'time_range_start': 'time_range_start',
'time_range_end': 'time_range_end',
'group_by': 'group_by',
'function': 'function',
'reaggregation': 'reaggregation',
'show_measures': 'show_measures',
'show_cost': 'show_cost',
'unit': 'unit',
'filters': 'filters',
'billing_user': '******',
}
try:
mapping = cc.charts.mappings.get(definition_id=args.id)
except exc.HTTPNotFound:
raise exc.CommandError('Chart definition not found: %s' %
args.counter_name)
for k, v in vars(args).items():
if k in arg_to_field_mapping:
if v is not None:
if k == "billing_user":
setattr(mapping, k, "true" in v.lower() or "1" in v)
elif k == "show_measures" or k == "show_cost":
setattr(mapping, k, "true" in v.lower() or "1" in v)
else:
setattr(mapping, k, v)
utils.print_dict(
cc.charts.mappings.update(
id=mapping.dirty_fields["id"],
gnocchi_metric=mapping.dirty_fields["gnocchi_metric"],
name=mapping.dirty_fields["name"],
granularities=mapping.dirty_fields["granularities"],
show_measures=mapping.dirty_fields["show_measures"],
show_cost=mapping.dirty_fields["show_cost"],
function=mapping.dirty_fields["function"],
reaggregation=mapping.dirty_fields["reaggregation"],
description=mapping.dirty_fields["description"],
time_range_start=mapping.dirty_fields["time_range_start"],
time_range_end=mapping.dirty_fields["time_range_end"],
group_by=mapping.dirty_fields["group_by"],
unit=mapping.dirty_fields["unit"],
filters=mapping.dirty_fields["filters"],
chart_type=mapping.dirty_fields["chart_type"],
billing_user=mapping.dirty_fields["billing_user"]).to_dict())
def do_widget_definition_update(cc, args={}):
"""Update a metric definition."""
arg_to_field_mapping = {
'widget_type': 'widget_type',
'name': 'name',
'description': 'description',
'metrics': 'metrics',
'granularities': 'granularities',
'time_range_start': 'time_range_start',
'time_range_end': 'time_range_end',
'group_by': 'group_by',
'top_n': 'top_n',
'reverse_top': 'reverse_top',
'filters': 'filters',
'billing_user': '******',
'items_per_page': 'items_per_page',
'hidden': 'hidden'
}
try:
mapping = cc.metrics.widgets.get(definition_id=args.id)
except exc.HTTPNotFound:
raise exc.CommandError('Metric definition not found: %s' %
args.counter_name)
for k, v in vars(args).items():
if k in arg_to_field_mapping:
if v is not None:
if k == "billing_user" or k == "hidden":
setattr(mapping, k, "true" in v.lower() or "1" in v)
else:
setattr(mapping, k, v)
cc.metrics.widgets.update(
id=mapping.dirty_fields["id"],
widget_type=mapping.dirty_fields["widget_type"],
name=mapping.dirty_fields["name"],
metrics=mapping.dirty_fields["metrics"],
granularities=mapping.dirty_fields["granularities"],
description=mapping.dirty_fields["description"],
time_range_start=mapping.dirty_fields["time_range_start"],
time_range_end=mapping.dirty_fields["time_range_end"],
group_by=mapping.dirty_fields["group_by"],
top_n=mapping.dirty_fields["top_n"],
reverse_top=mapping.dirty_fields["reverse_top"],
filters=mapping.dirty_fields["filters"],
billing_user=mapping.dirty_fields["billing_user"],
items_per_page=mapping.dirty_fields["items_per_page"],
hidden=mapping.dirty_fields["hidden"])
def args_array_to_list_of_dicts(kwargs, key_to_convert):
"""Converts ['a=1;b=2','c=3;d=4'] to [{a:1,b:2},{c:3,d:4}]."""
values_to_convert = kwargs.get(key_to_convert)
if values_to_convert:
try:
kwargs[key_to_convert] = []
for lst in values_to_convert:
pairs = lst.split(";")
dct = dict()
for pair in pairs:
kv = pair.split("=", 1)
dct[kv[0]] = kv[1].strip(" \"'") # strip spaces and quotes
kwargs[key_to_convert].append(dct)
except Exception:
raise exc.CommandError(
'%s must be a list of key1=value1;key2=value2;... not "%s"' % (
key_to_convert, values_to_convert))
return kwargs
def do_rating_threshold_rule_update(cc, args={}):
"""Update a threshold rule."""
arg_to_field_mapping = {
'id': 'id',
'cost': 'cost',
'level': 'level',
'type': 'type',
'valid_since': 'valid_since',
'valid_until': 'valid_until',
'providers': 'providers',
}
try:
threshold_rule = cc.gnocchi.threshold_rules.get(id=args.id)
except exc.HTTPNotFound:
raise exc.CommandError('Modules not found: %s' % args.counter_name)
for k, v in vars(args).items():
if k in arg_to_field_mapping:
if v is not None:
setattr(threshold_rule, k, v)
cc.gnocchi.threshold_rules.update(**threshold_rule.dirty_fields)
def do_dashboard_definition_update(cc, args={}):
"""Update a dashboard definition."""
arg_to_field_mapping = {
'id': 'id',
'name': 'name',
'charts': 'charts',
'charts_width': 'charts_width',
'charts_height': 'charts_height',
'charts_x': 'charts_x',
'charts_y': 'charts_y',
'description': 'description',
'billing_user': '******',
'is_default': 'is_default'
}
try:
mapping = cc.charts.dashboards.get(definition_id=args.id)
except exc.HTTPNotFound:
raise exc.CommandError('Dashboard definition not found: %s' %
args.counter_name)
for k, v in vars(args).items():
if k in arg_to_field_mapping:
if v is not None:
if k == "billing_user":
setattr(mapping, k, "true" in v.lower() or "1" in v)
elif k == "is_default":
setattr(mapping, k, "true" in v.lower() or "1" in v)
else:
setattr(mapping, k, v)
data_dict = cc.charts.dashboards.update(
id=mapping.dirty_fields["id"],
name=mapping.dirty_fields["name"],
charts=mapping.dirty_fields["charts"],
charts_width=mapping.dirty_fields["charts_width"],
charts_height=mapping.dirty_fields["charts_height"],
charts_x=mapping.dirty_fields["charts_x"],
charts_y=mapping.dirty_fields["charts_y"],
description=mapping.dirty_fields["description"],
billing_user=mapping.dirty_fields["billing_user"],
is_default=mapping.dirty_fields["is_default"]).to_dict()
utils.print_dict(data_dict)
def find_resource(manager, name_or_id):
"""Helper for the _find_* methods."""
# first try to get entity as integer id
try:
if isinstance(name_or_id, int) or name_or_id.isdigit():
return manager.get(int(name_or_id))
except exc.HTTPNotFound:
pass
# now try to get entity as uuid
try:
uuid.UUID(str(name_or_id))
return manager.get(name_or_id)
except (ValueError, exc.HTTPNotFound):
pass
# finally try to find entity by name
try:
return manager.find(name=name_or_id)
except exc.HTTPNotFound:
msg = ("No %s with a name or ID of '%s' exists." %
(manager.resource_class.__name__.lower(), name_or_id))
raise exc.CommandError(msg)
def _get_keystone_session(**kwargs):
# TODO(fabgia): the heavy lifting here should be really done by Keystone.
# Unfortunately Keystone does not support a richer method to perform
# discovery and return a single viable URL. A bug against Keystone has
# been filed: https://bugs.launchpad.net/python-keystoneclient/+bug/1330677
# first create a Keystone session
cacert = kwargs.pop('cacert', None)
cert = kwargs.pop('cert', None)
key = kwargs.pop('key', None)
insecure = kwargs.pop('insecure', False)
auth_url = kwargs.pop('auth_url', None)
project_id = kwargs.pop('project_id', None)
project_name = kwargs.pop('project_name', None)
if insecure:
verify = False
else:
verify = cacert or True
if cert and key:
# passing cert and key together is deprecated in favour of the
# requests lib form of having the cert and key as a tuple
cert = (cert, key)
# create the keystone client session
ks_session = session.Session(verify=verify, cert=cert)
v2_auth_url, v3_auth_url = _discover_auth_versions(ks_session, auth_url)
username = kwargs.pop('username', None)
user_id = kwargs.pop('user_id', None)
user_domain_name = kwargs.pop('user_domain_name', None)
user_domain_id = kwargs.pop('user_domain_id', None)
domain_name = kwargs.pop('domain_name', None)
domain_id = kwargs.pop('domain_id', None)
project_domain_name = kwargs.pop('project_domain_name', None)
project_domain_id = kwargs.pop('project_domain_id', None)
auth = None
use_domain = (user_domain_id or user_domain_name or project_domain_id
or project_domain_name)
use_v3 = v3_auth_url and (use_domain or (not v2_auth_url))
use_v2 = v2_auth_url and not use_domain
if use_v3:
# the auth_url as v3 specified
# e.g. http://no.where:5000/v3
# Keystone will return only v3 as viable option
auth = v3_auth.Password(v3_auth_url,
username=username,
password=kwargs.pop('password', None),
user_id=user_id,
user_domain_name=user_domain_name,
user_domain_id=user_domain_id,
domain_name=domain_name,
domain_id=domain_id)
elif use_v2:
# the auth_url as v2 specified
# e.g. http://no.where:5000/v2.0
# Keystone will return only v2 as viable option
auth = v2_auth.Password(v2_auth_url,
username,
kwargs.pop('password', None),
tenant_id=project_id,
tenant_name=project_name)
else:
raise exc.CommandError('Unable to determine the Keystone version '
'to authenticate with using the given '
'auth_url.')
ks_session.auth = auth
return ks_session
def do_rating_metric_rule_get(cc, args={}):
"""Get a metric rule."""
try:
cc.gnocchi.metric_rules.get(metric_rule_id=args.id)
except exc.HTTPNotFound:
raise exc.CommandError('Metric rule not found: %s' % args.id)
def do_rating_metadata_rule_delete(cc, args={}):
"""Delete a metadata rule."""
try:
cc.gnocchi.metadata_rules.delete(metadata_rule_id=args.id)
except exc.HTTPNotFound:
raise exc.CommandError('Metadata rule not found: %s' % args.id)
def do_rating_threshold_rule_delete(cc, args={}):
"""Delete a threshold rule."""
try:
cc.gnocchi.threshold_rules.delete(threshold_rule_id=args.id)
except exc.HTTPNotFound:
raise exc.CommandError('Threshold rule not found: %s' % args.id)
