def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
allowed_type = ['compute', 'storage', 'baremetal']
params = {}
if parsed_args.audit:
params["audit"] = parsed_args.audit
if parsed_args.type:
if parsed_args.type not in allowed_type:
raise exceptions.CommandError('Type %s error, '
'Please check the valid type!' %
parsed_args.type)
params["data_model_type"] = parsed_args.type
try:
data_model = client.data_model.list(**params)
except exceptions.HTTPNotFound as exc:
raise exceptions.CommandError(str(exc))
# TODO(chenker) Add Storage MODEL_FIELDS when using Storage Datamodel.
if parsed_args.detail:
fields = res_fields.COMPUTE_MODEL_LIST_FIELDS
field_labels = res_fields.COMPUTE_MODEL_LIST_FIELD_LABELS
else:
fields = res_fields.COMPUTE_MODEL_SHORT_LIST_FIELDS
field_labels = res_fields.COMPUTE_MODEL_SHORT_LIST_FIELD_LABELS
return (field_labels, (self.get_tuple(item, fields)
for item in data_model.context))
def check_api_version(check_version):
"""Validate version supplied by user
Returns:
* True if version is OK
* False if the version has not been checked and the previous plugin
check should be performed
* throws an exception if the version is no good
"""
infra_api_version = api_versioning.get_api_version(check_version)
# Bypass X.latest format microversion
if not infra_api_version.is_latest():
if infra_api_version > api_versioning.APIVersion("2.0"):
if not infra_api_version.matches(
watcherclient.API_MIN_VERSION,
watcherclient.API_MAX_VERSION,
):
msg = "versions supported by client: %(min)s - %(max)s" % {
"min": watcherclient.API_MIN_VERSION.get_string(),
"max": watcherclient.API_MAX_VERSION.get_string(),
}
raise exceptions.CommandError(msg)
return True
def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
if parsed_args.detail:
fields = res_fields.GOAL_FIELDS
field_labels = res_fields.GOAL_FIELD_LABELS
else:
fields = res_fields.GOAL_SHORT_LIST_FIELDS
field_labels = res_fields.GOAL_SHORT_LIST_FIELD_LABELS
params = {}
params.update(
common_utils.common_params_for_list(
parsed_args, fields, field_labels))
try:
data = client.goal.list(**params)
except exceptions.HTTPNotFound as ex:
raise exceptions.CommandError(str(ex))
if parsed_args.formatter == 'table':
for goal in data:
# Update the raw efficacy specs with the formatted one
goal.efficacy_specification = (
self._format_indicator_spec_table(goal, parsed_args))
return (field_labels,
(utils.get_item_properties(item, fields) for item in data))
def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
params = {}
# Optional
if parsed_args.goal:
params['goal'] = parsed_args.goal
# Optional
if parsed_args.strategy:
params['strategy'] = parsed_args.strategy
if parsed_args.detail:
fields = res_fields.AUDIT_FIELDS
field_labels = res_fields.AUDIT_FIELD_LABELS
else:
fields = res_fields.AUDIT_SHORT_LIST_FIELDS
field_labels = res_fields.AUDIT_SHORT_LIST_FIELD_LABELS
params.update(
common_utils.common_params_for_list(parsed_args, fields,
field_labels))
try:
data = client.audit.list(**params)
for audit in data:
if audit.strategy_name is None:
audit.strategy_name = 'auto'
except exceptions.HTTPNotFound as ex:
raise exceptions.CommandError(str(ex))
return (field_labels, (utils.get_item_properties(item, fields)
for item in data))
def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
action_plan_uuid = parsed_args.action_plan
if not uuidutils.is_uuid_like(action_plan_uuid):
raise exceptions.ValidationError()
try:
action_plan = client.action_plan.get(action_plan_uuid)
except exceptions.HTTPNotFound as exc:
raise exceptions.CommandError(str(exc))
if parsed_args.formatter == 'table':
# Update the raw efficacy indicators with the formatted ones
action_plan.efficacy_indicators = (self._format_indicators(
action_plan, parsed_args))
# Update the raw global efficacy with the formatted one
action_plan.global_efficacy = self._format_global_efficacy(
action_plan.global_efficacy, parsed_args)
columns = res_fields.ACTION_PLAN_FIELDS
column_headers = res_fields.ACTION_PLAN_FIELD_LABELS
return column_headers, utils.get_item_properties(action_plan, columns)
def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
params = {}
if parsed_args.action_plan is not None:
params['action_plan'] = parsed_args.action_plan
if parsed_args.audit is not None:
params['audit'] = parsed_args.audit
if parsed_args.detail:
fields = res_fields.ACTION_FIELDS
field_labels = res_fields.ACTION_FIELD_LABELS
else:
fields = res_fields.ACTION_SHORT_LIST_FIELDS
field_labels = res_fields.ACTION_SHORT_LIST_FIELD_LABELS
params.update(
common_utils.common_params_for_list(parsed_args, fields,
field_labels))
try:
data = client.action.list(**params)
except exceptions.HTTPNotFound as ex:
raise exceptions.CommandError(str(ex))
return (field_labels, (utils.get_item_properties(item, fields)
for item in data))
def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
params = {}
if parsed_args.detail:
fields = res_fields.STRATEGY_FIELDS
field_labels = res_fields.STRATEGY_FIELD_LABELS
else:
fields = res_fields.STRATEGY_SHORT_LIST_FIELDS
field_labels = res_fields.STRATEGY_SHORT_LIST_FIELD_LABELS
if parsed_args.goal:
params["goal"] = parsed_args.goal
params.update(
common_utils.common_params_for_list(
parsed_args, fields, field_labels))
try:
data = client.strategy.list(**params)
except exceptions.HTTPNotFound as ex:
raise exceptions.CommandError(str(ex))
return (field_labels,
(utils.get_item_properties(item, fields) for item in data))
def common_params_for_list(args, fields, field_labels):
"""Generate 'params' dict that is common for every 'list' command.
:param args: arguments from command line.
:param fields: possible fields for sorting.
:param field_labels: possible field labels for sorting.
:returns: a dict with params to pass to the client method.
"""
params = {}
if args.limit is not None:
if args.limit < 0:
raise exc.CommandError(
_('Expected non-negative --limit, got %s') % args.limit)
params['limit'] = args.limit
if args.sort_key is not None:
# Support using both heading and field name for sort_key
fields_map = dict(zip(field_labels, fields))
fields_map.update(zip(fields, fields))
try:
sort_key = fields_map[args.sort_key]
except KeyError:
raise exc.CommandError(
_("%(sort_key)s is an invalid field for sorting, "
"valid values for --sort-key are: %(valid)s") % {
'sort_key': args.sort_key,
'valid': list(fields_map)
})
params['sort_key'] = sort_key
if args.sort_dir is not None:
if args.sort_dir not in ('asc', 'desc'):
raise exc.CommandError(
_("%s is an invalid value for sort direction, "
"valid values for --sort-dir are: 'asc', 'desc'") %
args.sort_dir)
params['sort_dir'] = args.sort_dir
marker = getattr(args, 'marker', None)
if marker is not None:
params['marker'] = marker
params['detail'] = args.detail
return params
def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
try:
action = client.action.get(parsed_args.action)
except exceptions.HTTPNotFound as exc:
raise exceptions.CommandError(str(exc))
columns = res_fields.ACTION_FIELDS
column_headers = res_fields.ACTION_FIELD_LABELS
return column_headers, utils.get_item_properties(action, columns)
def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
try:
strategy = client.strategy.get(parsed_args.strategy)
except exceptions.HTTPNotFound as exc:
raise exceptions.CommandError(str(exc))
strategy.parameters_spec = self._format_spec(strategy)
columns = res_fields.STRATEGY_FIELDS
column_headers = res_fields.STRATEGY_FIELD_LABELS
return column_headers, utils.get_item_properties(strategy, columns)
def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
try:
requirements = client.strategy.state(parsed_args.strategy)
except exceptions.HTTPNotFound as exc:
raise exceptions.CommandError(str(exc))
requirements = self._format_spec(requirements)
columns = res_fields.STRATEGY_STATE_FIELDS
column_headers = res_fields.STRATEGY_STATE_FIELD_LABELS
return (column_headers,
(utils.get_item_properties(item, columns)
for item in requirements))
def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
try:
audit = client.audit.get(parsed_args.audit)
if audit.strategy_name is None:
audit.strategy_name = 'auto'
except exceptions.HTTPNotFound as exc:
raise exceptions.CommandError(str(exc))
columns = res_fields.AUDIT_FIELDS
column_headers = res_fields.AUDIT_FIELD_LABELS
return column_headers, utils.get_item_properties(audit, columns)
def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
try:
scoring_engine = client.scoring_engine.get(
parsed_args.scoring_engine)
except exceptions.HTTPNotFound as exc:
raise exceptions.CommandError(str(exc))
columns = res_fields.SCORING_ENGINE_FIELDS
column_headers = res_fields.SCORING_ENGINE_FIELD_LABELS
return column_headers, utils.get_item_properties(
scoring_engine, columns)
def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
audit_template_uuid = parsed_args.audit_template
try:
audit_template = client.audit_template.get(audit_template_uuid)
except exceptions.HTTPNotFound as exc:
raise exceptions.CommandError(str(exc))
columns = res_fields.AUDIT_TEMPLATE_FIELDS
column_headers = res_fields.AUDIT_TEMPLATE_FIELD_LABELS
return column_headers, utils.get_item_properties(
audit_template, columns)
def args_array_to_patch(op, attributes):
patch = []
for attr in attributes:
# Sanitize
if not attr.startswith('/'):
attr = '/' + attr
if op in ['add', 'replace']:
path, value = split_and_deserialize(attr)
patch.append({'op': op, 'path': path, 'value': value})
elif op == "remove":
# For remove only the key is needed
patch.append({'op': op, 'path': attr})
else:
raise exc.CommandError(_('Unknown PATCH operation: %s') % op)
return patch
def split_and_deserialize(string):
"""Split and try to JSON deserialize a string.
Gets a string with the KEY=VALUE format, split it (using '=' as the
separator) and try to JSON deserialize the VALUE.
:returns: A tuple of (key, value).
"""
try:
key, value = string.split("=", 1)
except ValueError:
raise exc.CommandError(_('Attributes must be a list of '
'PATH=VALUE not "%s"') % string)
try:
value = json.loads(value)
except ValueError:
pass
return (key, value)
def take_action(self, parsed_args):
client = getattr(self.app.client_manager, "infra-optim")
try:
goal = client.goal.get(parsed_args.goal)
except exceptions.HTTPNotFound as exc:
raise exceptions.CommandError(str(exc))
columns = res_fields.GOAL_FIELDS
column_headers = res_fields.GOAL_FIELD_LABELS
if parsed_args.formatter == 'table':
indicator_specs = ''
# Format complex data types:
for indicator_spec in goal.efficacy_specification:
indicator_specs += self._format_indicator_spec_table(
indicator_spec, parsed_args)
# Update the raw efficacy specs with the formatted one
goal.efficacy_specification = indicator_specs
return column_headers, utils.get_item_properties(goal, columns)
