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_chart_definition_create(cc, args):
out = cc.charts.mappings.create(
gnocchi_metric=args.gnocchi_metric,
name=args.name,
description=args.description,
granularities=args.granularities,
time_range_start=args.time_range_start,
time_range_end=args.time_range_end,
group_by=args.group_by,
function=args.function,
reaggregation=args.reaggregation,
show_measures=("true" in args.show_measures.lower()
or "1" in args.show_measures),
show_cost="true" in args.show_cost.lower() or "1" in args.show_cost,
unit=args.unit,
filters=args.filters,
chart_type=args.chart_type,
billing_user=(True if args.billing_user and
(args.billing_user.lower() == 'true'
or args.billing_user.lower() == '1') else False))
data_dict = out.to_dict()
filters = data_dict["filters"] if data_dict["filters"] else ''
for chunk in [filters[i:i + 80] for i in range(0, len(filters), 80)]:
data_dict["filters"] += chunk + "\n"
if data_dict["filters"]:
data_dict["filters"] = data_dict["filters"][:-1]
utils.print_dict(data_dict)
def do_widget_definition_create(cc, args):
out = cc.metrics.widgets.create(
widget_type=args.widget_type,
name=args.name,
description=args.description,
metrics=args.metrics,
granularities=args.granularities,
time_range_start=args.time_range_start,
time_range_end=args.time_range_end,
group_by=args.group_by,
filters=args.filters,
items_per_page=args.items_per_page,
billing_user=True if args.billing_user and
(args.billing_user.lower() == 'true'
or args.billing_user.lower() == '1') else False,
top_n=args.top_n,
reverse_top=True if args.billing_user and
(args.reverse_top.lower() == 'true' or args.reverse_top.lower() == '1')
else False,
hidden=True if args.hidden and
(args.hidden.lower() == 'true' or args.hidden.lower() == '1') else
False)
data_dict = out.to_dict()
filters = data_dict["filters"] if data_dict["filters"] else ''
for chunk in [filters[i:i + 80] for i in range(0, len(filters), 80)]:
data_dict["filters"] += chunk + "\n"
if data_dict["filters"]:
data_dict["filters"] = data_dict["filters"][:-1]
utils.print_dict(data_dict)
def do_metric_definition_get(cc, args):
data = cc.metrics.mappings.get(definition_id=args.id)
data_dict = data.to_dict()
filters = data_dict["filters"] if data_dict["filters"] else ""
data_dict["filters"] = "\n"
for chunk in [filters[i:i + 80] for i in range(0, len(filters), 80)]:
data_dict["filters"] += chunk + "\n"
utils.print_dict(data_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_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_widget_definition_get(cc, args):
data = cc.metrics.widgets.get(definition_id=args.id)
data_dict = data.to_dict()
filters = data_dict["filters"] if data_dict["filters"] else ''
for chunk in [filters[i:i + 80] for i in range(0, len(filters), 80)]:
data_dict["filters"] += chunk + "\n"
if data_dict["filters"]:
data_dict["filters"] = data_dict["filters"][:-1]
utils.print_dict(data_dict)
def do_metric_definition_create(cc, args):
out = cc.metrics.mappings.create(
gnocchi_metric=args.gnocchi_metric,
name=args.name,
description=args.description,
show_measures=("true" in args.show_measures.lower()
or "1" in args.show_measures),
show_cost="true" in args.show_cost.lower() or "1" in args.show_cost,
function=args.function,
reaggregation=args.reaggregation,
unit=args.unit)
data_dict = out.to_dict()
utils.print_dict(data_dict)
def do_rating_metadata_rule_set_create(cc, args={}):
"""Create a metadata rule set."""
arg_to_field_mapping = {
'name': 'name',
'metric_rule_set_id': 'metric_rule_set_id'
}
fields = {}
for k, v in vars(args).items():
if k in arg_to_field_mapping:
if v is not None:
fields[arg_to_field_mapping.get(k, k)] = v
out = cc.gnocchi.metadata_rule_sets.create(**fields)
utils.print_dict(out.to_dict())
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_rating_metric_rule_set_create(cc, args={}):
"""Create a metric rule set."""
arg_to_field_mapping = {
'gnocchi_metric': 'gnocchi_metric',
'aggregation_function': 'aggregation_function',
'gnocchi_unit': 'gnocchi_unit',
'billing_unit': 'billing_unit'
}
fields = {}
for k, v in vars(args).items():
if k in arg_to_field_mapping:
if v is not None:
fields[arg_to_field_mapping.get(k, k)] = v
out = cc.gnocchi.metric_rule_sets.create(**fields)
utils.print_dict(out.to_dict())
def do_aws_ri_coverage_get(cc, args):
aws_ri_coverage = cc.reports.get_aws_ri_coverage(
account_id=args.account_id,
secret_access_key=args.secret_access_key, u_domain_id=args.u_domain_id)
valid_terms = ['1_year', '3_years_standard', '3_years_convertible']
valid_offering_types = ['no_upfront', 'partial_upfront', 'all_upfront']
choosed_term = (args.term_duration if args.term_duration is not None and
args.term_duration in valid_terms else "1_year")
choosed_offering_type = (args.offering_type if args.offering_type is not
None and args.offering_type in
valid_offering_types else "no_upfront")
for element in aws_ri_coverage:
element['potential_savings_pm'] = element['potential_savings_pm'][
choosed_term][choosed_offering_type]
utils.print_dict(element)
return aws_ri_coverage
def do_rating_metric_rule_create(cc, args={}):
"""Create a metric rule."""
arg_to_field_mapping = {
'cost': 'cost',
'type': 'type',
'metric_rule_set_id': 'metric_rule_set_id',
'valid_since': 'valid_since',
'valid_until': 'valid_until',
'providers': 'providers',
}
fields = {}
for k, v in vars(args).items():
if k in arg_to_field_mapping:
if v is not None:
fields[arg_to_field_mapping.get(k, k)] = v
out = cc.gnocchi.metric_rules.create(**fields)
utils.print_dict(out.to_dict())
def do_dashboard_definition_create(cc, args):
out = cc.charts.dashboards.create(
name=args.name,
description=args.description,
charts=args.charts,
charts_width=args.charts_width,
charts_height=args.charts_height,
charts_x=args.charts_x,
charts_y=args.charts_y,
billing_user=(True if args.billing_user and
(args.billing_user.lower() == 'true'
or args.billing_user.lower() == '1') else False),
is_default=(True if args.is_default and
(args.is_default.lower() == 'true'
or args.is_default.lower() == '1') else False))
data_dict = out.to_dict()
utils.print_dict(data_dict)
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 do_dashboard_definition_get(cc, args):
data = cc.charts.dashboards.get(definition_id=args.id)
data_dict = data.to_dict()
utils.print_dict(data_dict)