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)