1d033f9053
Fix some exception messages because some exception messages are not outputed as expected. In addition, the codes that seems to improve readability by explicitly specifying the arguments are also modified. Change-Id: I425d15ea9f5a3d0b6132ffd03cb577e583239c3a Closes-Bug: #1881510
729 lines
26 KiB
Python
729 lines
26 KiB
Python
# Copyright 2012 OpenStack Foundation.
|
|
# All Rights Reserved
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
#
|
|
|
|
from __future__ import print_function
|
|
|
|
import abc
|
|
import argparse
|
|
import logging
|
|
import re
|
|
|
|
from cliff.formatters import table
|
|
from cliff import lister
|
|
from cliff import show
|
|
from oslo_serialization import jsonutils
|
|
import six
|
|
|
|
from tackerclient.common._i18n import _
|
|
from tackerclient.common import command
|
|
from tackerclient.common import exceptions
|
|
from tackerclient.common import utils
|
|
|
|
HEX_ELEM = '[0-9A-Fa-f]'
|
|
UUID_PATTERN = '-'.join([HEX_ELEM + '{8}', HEX_ELEM + '{4}',
|
|
HEX_ELEM + '{4}', HEX_ELEM + '{4}',
|
|
HEX_ELEM + '{12}'])
|
|
|
|
|
|
def _get_resource_plural(resource, client):
|
|
plurals = getattr(client, 'EXTED_PLURALS', [])
|
|
for k in plurals:
|
|
if plurals[k] == resource:
|
|
return k
|
|
return resource + 's'
|
|
|
|
|
|
def find_resourceid_by_id(client, resource, resource_id):
|
|
resource_plural = _get_resource_plural(resource, client)
|
|
obj_lister = getattr(client, "list_%s" % resource_plural)
|
|
if resource == 'event':
|
|
match = resource_id.isdigit() and resource_id != 0
|
|
else:
|
|
match = re.match(UUID_PATTERN, resource_id)
|
|
collection = resource_plural
|
|
if match:
|
|
data = obj_lister(id=resource_id, fields='id')
|
|
if data and data[collection]:
|
|
return data[collection][0]['id']
|
|
not_found_message = (_("Unable to find %(resource)s with id "
|
|
"'%(id)s'") %
|
|
{'resource': resource, 'id': resource_id})
|
|
# 404 is used to simulate server side behavior
|
|
raise exceptions.TackerClientException(
|
|
message=not_found_message, status_code=404)
|
|
|
|
|
|
def _find_resourceid_by_name(client, resource, name):
|
|
resource_plural = _get_resource_plural(resource, client)
|
|
obj_lister = getattr(client, "list_%s" % resource_plural)
|
|
data = obj_lister(name=name, fields='id')
|
|
collection = resource_plural
|
|
info = data[collection]
|
|
if len(info) > 1:
|
|
raise exceptions.TackerClientNoUniqueMatch(resource=resource,
|
|
name=name)
|
|
elif len(info) == 0:
|
|
not_found_message = (_("Unable to find %(resource)s with name "
|
|
"'%(name)s'") %
|
|
{'resource': resource, 'name': name})
|
|
# 404 is used to simulate server side behavior
|
|
raise exceptions.TackerClientException(
|
|
message=not_found_message, status_code=404)
|
|
else:
|
|
return info[0]['id']
|
|
|
|
|
|
def find_resourceid_by_name_or_id(client, resource, name_or_id):
|
|
try:
|
|
return find_resourceid_by_id(client, resource, name_or_id)
|
|
except exceptions.TackerClientException:
|
|
return _find_resourceid_by_name(client, resource, name_or_id)
|
|
|
|
|
|
def add_show_list_common_argument(parser):
|
|
parser.add_argument(
|
|
'-D', '--show-details',
|
|
help=_('Show detailed info'),
|
|
action='store_true',
|
|
default=False,)
|
|
parser.add_argument(
|
|
'--show_details',
|
|
action='store_true',
|
|
help=argparse.SUPPRESS)
|
|
parser.add_argument(
|
|
'--fields',
|
|
help=argparse.SUPPRESS,
|
|
action='append',
|
|
default=[])
|
|
parser.add_argument(
|
|
'-F', '--field',
|
|
dest='fields', metavar='FIELD',
|
|
help=_('Specify the field(s) to be returned by server. You can '
|
|
'repeat this option.'),
|
|
action='append',
|
|
default=[])
|
|
|
|
|
|
def add_pagination_argument(parser):
|
|
parser.add_argument(
|
|
'-P', '--page-size',
|
|
dest='page_size', metavar='SIZE', type=int,
|
|
help=_("Specify retrieve unit of each request, then split one request "
|
|
"to several requests"),
|
|
default=None)
|
|
|
|
|
|
def add_sorting_argument(parser):
|
|
parser.add_argument(
|
|
'--sort-key',
|
|
dest='sort_key', metavar='FIELD',
|
|
action='append',
|
|
help=_("Sorts the list by the specified fields in the specified "
|
|
"directions. You can repeat this option, but you must "
|
|
"specify an equal number of sort_dir and sort_key values. "
|
|
"Extra sort_dir options are ignored. Missing sort_dir options "
|
|
"use the default asc value."),
|
|
default=[])
|
|
parser.add_argument(
|
|
'--sort-dir',
|
|
dest='sort_dir', metavar='{asc,desc}',
|
|
help=_("Sorts the list in the specified direction. You can repeat "
|
|
"this option."),
|
|
action='append',
|
|
default=[],
|
|
choices=['asc', 'desc'])
|
|
|
|
|
|
def is_number(s):
|
|
try:
|
|
float(s) # for int, long and float
|
|
except ValueError:
|
|
try:
|
|
complex(s) # for complex
|
|
except ValueError:
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
def _process_previous_argument(current_arg, _value_number, current_type_str,
|
|
_list_flag, _values_specs, _clear_flag,
|
|
values_specs):
|
|
if current_arg is not None:
|
|
if _value_number == 0 and (current_type_str or _list_flag):
|
|
# This kind of argument should have value
|
|
raise exceptions.CommandError(
|
|
message=_("Invalid values_specs %s") % ' '.join(values_specs))
|
|
if _value_number > 1 or _list_flag or current_type_str == 'list':
|
|
current_arg.update({'nargs': '+'})
|
|
elif _value_number == 0:
|
|
if _clear_flag:
|
|
# if we have action=clear, we use argument's default
|
|
# value None for argument
|
|
_values_specs.pop()
|
|
else:
|
|
# We assume non value argument as bool one
|
|
current_arg.update({'action': 'store_true'})
|
|
|
|
|
|
def parse_args_to_dict(values_specs):
|
|
'''It is used to analyze the extra command options to command.
|
|
|
|
Besides known options and arguments, our commands also support user to
|
|
put more options to the end of command line. For example,
|
|
list_nets -- --tag x y --key1 value1, where '-- --tag x y --key1 value1'
|
|
is extra options to our list_nets. This feature can support V1.0 API's
|
|
fields selection and filters. For example, to list networks which has name
|
|
'test4', we can have list_nets -- --name=test4.
|
|
|
|
value spec is: --key type=int|bool|... value. Type is one of Python
|
|
built-in types. By default, type is string. The key without value is
|
|
a bool option. Key with two values will be a list option.
|
|
|
|
'''
|
|
|
|
# values_specs for example: '-- --tag x y --key1 type=int value1'
|
|
# -- is a pseudo argument
|
|
values_specs_copy = values_specs[:]
|
|
if values_specs_copy and values_specs_copy[0] == '--':
|
|
del values_specs_copy[0]
|
|
# converted ArgumentParser arguments for each of the options
|
|
_options = {}
|
|
# the argument part for current option in _options
|
|
current_arg = None
|
|
# the string after remove meta info in values_specs
|
|
# for example, '--tag x y --key1 value1'
|
|
_values_specs = []
|
|
# record the count of values for an option
|
|
# for example: for '--tag x y', it is 2, while for '--key1 value1', it is 1
|
|
_value_number = 0
|
|
# list=true
|
|
_list_flag = False
|
|
# action=clear
|
|
_clear_flag = False
|
|
# the current item in values_specs
|
|
current_item = None
|
|
# the str after 'type='
|
|
current_type_str = None
|
|
for _item in values_specs_copy:
|
|
if _item.startswith('--'):
|
|
# Deal with previous argument if any
|
|
_process_previous_argument(
|
|
current_arg, _value_number, current_type_str,
|
|
_list_flag, _values_specs, _clear_flag, values_specs)
|
|
|
|
# Init variables for current argument
|
|
current_item = _item
|
|
_list_flag = False
|
|
_clear_flag = False
|
|
current_type_str = None
|
|
if "=" in _item:
|
|
_value_number = 1
|
|
_item = _item.split('=')[0]
|
|
else:
|
|
_value_number = 0
|
|
if _item in _options:
|
|
raise exceptions.CommandError(
|
|
message=_("Duplicated "
|
|
"options %s") % ' '.join(values_specs))
|
|
else:
|
|
_options.update({_item: {}})
|
|
current_arg = _options[_item]
|
|
_item = current_item
|
|
elif _item.startswith('type='):
|
|
if current_arg is None:
|
|
raise exceptions.CommandError(
|
|
message=_("Invalid "
|
|
"values_specs %s") % ' '.join(values_specs))
|
|
if 'type' not in current_arg:
|
|
current_type_str = _item.split('=', 2)[1]
|
|
current_arg.update({'type': eval(current_type_str)})
|
|
if current_type_str == 'bool':
|
|
current_arg.update({'type': utils.str2bool})
|
|
elif current_type_str == 'dict':
|
|
current_arg.update({'type': utils.str2dict})
|
|
continue
|
|
elif _item == 'list=true':
|
|
_list_flag = True
|
|
continue
|
|
elif _item == 'action=clear':
|
|
_clear_flag = True
|
|
continue
|
|
|
|
if not _item.startswith('--'):
|
|
# All others are value items
|
|
# Make sure '--' occurs first and allow minus value
|
|
if (not current_item or '=' in current_item or
|
|
_item.startswith('-') and not is_number(_item)):
|
|
raise exceptions.CommandError(
|
|
message=_("Invalid "
|
|
"values_specs %s") % ' '.join(values_specs))
|
|
_value_number += 1
|
|
|
|
_values_specs.append(_item)
|
|
|
|
# Deal with last one argument
|
|
_process_previous_argument(
|
|
current_arg, _value_number, current_type_str,
|
|
_list_flag, _values_specs, _clear_flag, values_specs)
|
|
|
|
# populate the parser with arguments
|
|
_parser = argparse.ArgumentParser(add_help=False)
|
|
for opt, optspec in _options.items():
|
|
_parser.add_argument(opt, **optspec)
|
|
_args = _parser.parse_args(_values_specs)
|
|
|
|
result_dict = {}
|
|
for opt in _options.keys():
|
|
_opt = opt.split('--', 2)[1]
|
|
_opt = _opt.replace('-', '_')
|
|
_value = getattr(_args, _opt)
|
|
result_dict.update({_opt: _value})
|
|
return result_dict
|
|
|
|
|
|
def _merge_args(qCmd, parsed_args, _extra_values, value_specs):
|
|
"""Merge arguments from _extra_values into parsed_args.
|
|
|
|
If an argument value are provided in both and it is a list,
|
|
the values in _extra_values will be merged into parsed_args.
|
|
|
|
@param parsed_args: the parsed args from known options
|
|
@param _extra_values: the other parsed arguments in unknown parts
|
|
@param values_specs: the unparsed unknown parts
|
|
"""
|
|
temp_values = _extra_values.copy()
|
|
for key, value in temp_values.items():
|
|
if hasattr(parsed_args, key):
|
|
arg_value = getattr(parsed_args, key)
|
|
if arg_value is not None and value is not None:
|
|
if isinstance(arg_value, list):
|
|
if value and isinstance(value, list):
|
|
if (not arg_value or
|
|
isinstance(arg_value[0], type(value[0]))):
|
|
arg_value.extend(value)
|
|
_extra_values.pop(key)
|
|
|
|
|
|
def update_dict(obj, dict, attributes):
|
|
"""Update dict with fields from obj.attributes
|
|
|
|
:param obj: the object updated into dict
|
|
:param dict: the result dictionary
|
|
:param attributes: a list of attributes belonging to obj
|
|
"""
|
|
for attribute in attributes:
|
|
if hasattr(obj, attribute) and getattr(obj, attribute) is not None:
|
|
dict[attribute] = getattr(obj, attribute)
|
|
|
|
|
|
class TableFormater(table.TableFormatter):
|
|
"""This class is used to keep consistency with prettytable 0.6.
|
|
|
|
https://bugs.launchpad.net/python-tackerclient/+bug/1165962
|
|
"""
|
|
|
|
def emit_list(self, column_names, data, stdout, parsed_args):
|
|
if column_names:
|
|
super(TableFormater, self).emit_list(column_names, data, stdout,
|
|
parsed_args)
|
|
else:
|
|
stdout.write('\n')
|
|
|
|
|
|
# command.OpenStackCommand is abstract class so that metaclass of
|
|
# subclass must be subclass of metaclass of all its base.
|
|
# otherwise metaclass conflict exception is raised.
|
|
class TackerCommandMeta(abc.ABCMeta):
|
|
def __new__(cls, name, bases, cls_dict):
|
|
if 'log' not in cls_dict:
|
|
cls_dict['log'] = logging.getLogger(
|
|
cls_dict['__module__'] + '.' + name)
|
|
return super(TackerCommandMeta, cls).__new__(cls,
|
|
name, bases, cls_dict)
|
|
|
|
|
|
@six.add_metaclass(TackerCommandMeta)
|
|
class TackerCommand(command.OpenStackCommand):
|
|
|
|
api = 'nfv-orchestration'
|
|
values_specs = []
|
|
json_indent = None
|
|
|
|
def __init__(self, app, app_args):
|
|
super(TackerCommand, self).__init__(app, app_args)
|
|
# NOTE(markmcclain): This is no longer supported in cliff version 1.5.2
|
|
# see https://bugs.launchpad.net/python-tackerclient/+bug/1265926
|
|
|
|
# if hasattr(self, 'formatters'):
|
|
# self.formatters['table'] = TableFormater()
|
|
|
|
def get_client(self):
|
|
return self.app.client_manager.tacker
|
|
|
|
def get_parser(self, prog_name):
|
|
parser = super(TackerCommand, self).get_parser(prog_name)
|
|
parser.add_argument(
|
|
'--request-format',
|
|
help=_('The xml or json request format'),
|
|
default='json',
|
|
choices=['json', 'xml', ], )
|
|
parser.add_argument(
|
|
'--request_format',
|
|
choices=['json', 'xml', ],
|
|
help=argparse.SUPPRESS)
|
|
|
|
return parser
|
|
|
|
def format_output_data(self, data):
|
|
# Modify data to make it more readable
|
|
if self.resource in data:
|
|
for k, v in data[self.resource].items():
|
|
if isinstance(v, list):
|
|
value = '\n'.join(jsonutils.dumps(
|
|
i, indent=self.json_indent) if isinstance(i, dict)
|
|
else str(i) for i in v)
|
|
data[self.resource][k] = value
|
|
elif isinstance(v, dict):
|
|
value = jsonutils.dumps(v, indent=self.json_indent)
|
|
data[self.resource][k] = value
|
|
elif v is None:
|
|
data[self.resource][k] = ''
|
|
|
|
def add_known_arguments(self, parser):
|
|
pass
|
|
|
|
def args2body(self, parsed_args):
|
|
return {}
|
|
|
|
|
|
class CreateCommand(TackerCommand, show.ShowOne):
|
|
"""Create a resource for a given tenant
|
|
|
|
"""
|
|
|
|
api = 'nfv-orchestration'
|
|
resource = None
|
|
log = None
|
|
remove_output_fields = []
|
|
|
|
def get_parser(self, prog_name):
|
|
parser = super(CreateCommand, self).get_parser(prog_name)
|
|
parser.add_argument(
|
|
'--tenant-id', metavar='TENANT_ID',
|
|
help=_('The owner tenant ID'), )
|
|
parser.add_argument(
|
|
'--tenant_id',
|
|
help=argparse.SUPPRESS)
|
|
self.add_known_arguments(parser)
|
|
return parser
|
|
|
|
def get_data(self, parsed_args):
|
|
self.log.debug('get_data(%s)', parsed_args)
|
|
tacker_client = self.get_client()
|
|
tacker_client.format = parsed_args.request_format
|
|
_extra_values = parse_args_to_dict(self.values_specs)
|
|
_merge_args(self, parsed_args, _extra_values,
|
|
self.values_specs)
|
|
body = self.args2body(parsed_args)
|
|
body[self.resource].update(_extra_values)
|
|
obj_creator = getattr(tacker_client,
|
|
"create_%s" % self.resource)
|
|
data = obj_creator(body)
|
|
self.format_output_data(data)
|
|
# {u'network': {u'id': u'e9424a76-6db4-4c93-97b6-ec311cd51f19'}}
|
|
info = self.resource in data and data[self.resource] or None
|
|
if info:
|
|
print(_('Created a new %s:') % self.resource,
|
|
file=self.app.stdout)
|
|
for f in self.remove_output_fields:
|
|
if f in info:
|
|
info.pop(f)
|
|
else:
|
|
info = {'': ''}
|
|
return zip(*sorted(info.items()))
|
|
|
|
|
|
class UpdateCommand(TackerCommand):
|
|
"""Update resource's information."""
|
|
|
|
api = 'nfv-orchestration'
|
|
resource = None
|
|
log = None
|
|
allow_names = True
|
|
|
|
def get_parser(self, prog_name):
|
|
parser = super(UpdateCommand, self).get_parser(prog_name)
|
|
parser.add_argument(
|
|
'id', metavar=self.resource.upper(),
|
|
help=_('ID or name of %s to update') % self.resource)
|
|
self.add_known_arguments(parser)
|
|
return parser
|
|
|
|
def run(self, parsed_args):
|
|
self.log.debug('run(%s)', parsed_args)
|
|
tacker_client = self.get_client()
|
|
tacker_client.format = parsed_args.request_format
|
|
_extra_values = parse_args_to_dict(self.values_specs)
|
|
_merge_args(self, parsed_args, _extra_values,
|
|
self.values_specs)
|
|
body = self.args2body(parsed_args)
|
|
if self.resource in body:
|
|
body[self.resource].update(_extra_values)
|
|
else:
|
|
body[self.resource] = _extra_values
|
|
if not body[self.resource]:
|
|
raise exceptions.CommandError(
|
|
message=_("Must specify new"
|
|
" values to update %s") % self.resource)
|
|
if self.allow_names:
|
|
_id = find_resourceid_by_name_or_id(
|
|
tacker_client, self.resource, parsed_args.id)
|
|
else:
|
|
_id = find_resourceid_by_id(
|
|
tacker_client, self.resource, parsed_args.id)
|
|
obj_updator = getattr(tacker_client,
|
|
"update_%s" % self.resource)
|
|
obj_updator(_id, body)
|
|
print((_('Updated %(resource)s: %(id)s') %
|
|
{'id': parsed_args.id, 'resource': self.resource}),
|
|
file=self.app.stdout)
|
|
return
|
|
|
|
|
|
class DeleteCommand(TackerCommand):
|
|
"""Delete given resource(s)
|
|
|
|
"""
|
|
|
|
api = 'nfv-orchestration'
|
|
resource = None
|
|
log = None
|
|
allow_names = True
|
|
deleted_msg = {}
|
|
|
|
def get_parser(self, prog_name):
|
|
parser = super(DeleteCommand, self).get_parser(prog_name)
|
|
if self.allow_names:
|
|
help_str = _('IDs or names of %s to delete')
|
|
else:
|
|
help_str = _('IDs of %s to delete')
|
|
parser.add_argument(
|
|
'ids', nargs='+',
|
|
metavar=self.resource.upper(),
|
|
help=help_str % self.resource)
|
|
self.add_known_arguments(parser)
|
|
return parser
|
|
|
|
def run(self, parsed_args):
|
|
failure = False
|
|
deleted_ids = []
|
|
failed_items = {}
|
|
tacker_client = self.get_client()
|
|
tacker_client.format = parsed_args.request_format
|
|
obj_deleter = getattr(tacker_client,
|
|
"delete_%s" % self.resource)
|
|
body = self.args2body(parsed_args)
|
|
|
|
for resource_id in parsed_args.ids:
|
|
try:
|
|
if self.allow_names:
|
|
_id = find_resourceid_by_name_or_id(
|
|
tacker_client, self.resource, resource_id)
|
|
else:
|
|
_id = resource_id
|
|
if body:
|
|
obj_deleter(_id, body)
|
|
else:
|
|
obj_deleter(_id)
|
|
deleted_ids.append(resource_id)
|
|
except Exception as e:
|
|
failure = True
|
|
failed_items[resource_id] = e
|
|
if failure:
|
|
msg = ''
|
|
if deleted_ids:
|
|
status_msg = self.deleted_msg.get(self.resource, 'deleted')
|
|
msg = (_('Successfully %(status_msg)s %(resource)s(s):'
|
|
' %(deleted_list)s') % {'status_msg': status_msg,
|
|
'deleted_list':
|
|
', '.join(deleted_ids),
|
|
'resource': self.resource})
|
|
err_msg = _("\n\nUnable to delete the below"
|
|
" %s(s):") % self.resource
|
|
for failed_id, error in failed_items.items():
|
|
err_msg += (_('\n Cannot delete %(failed_id)s: %(error)s')
|
|
% {'failed_id': failed_id,
|
|
'error': error})
|
|
msg += err_msg
|
|
raise exceptions.CommandError(message=msg)
|
|
else:
|
|
print((_('All specified %(resource)s(s) %(msg)s successfully')
|
|
% {'msg': self.deleted_msg.get(self.resource, 'deleted'),
|
|
'resource': self.resource}))
|
|
return
|
|
|
|
|
|
class ListCommand(TackerCommand, lister.Lister):
|
|
"""List resources that belong to a given tenant
|
|
|
|
"""
|
|
|
|
api = 'nfv-orchestration'
|
|
resource = None
|
|
log = None
|
|
_formatters = {}
|
|
list_columns = []
|
|
unknown_parts_flag = True
|
|
pagination_support = False
|
|
sorting_support = False
|
|
|
|
def get_parser(self, prog_name):
|
|
parser = super(ListCommand, self).get_parser(prog_name)
|
|
add_show_list_common_argument(parser)
|
|
if self.pagination_support:
|
|
add_pagination_argument(parser)
|
|
if self.sorting_support:
|
|
add_sorting_argument(parser)
|
|
return parser
|
|
|
|
def args2search_opts(self, parsed_args):
|
|
search_opts = {}
|
|
fields = parsed_args.fields
|
|
if parsed_args.fields:
|
|
search_opts.update({'fields': fields})
|
|
if parsed_args.show_details:
|
|
search_opts.update({'verbose': 'True'})
|
|
return search_opts
|
|
|
|
def call_server(self, tacker_client, search_opts, parsed_args):
|
|
resource_plural = _get_resource_plural(self.resource, tacker_client)
|
|
obj_lister = getattr(tacker_client, "list_%s" % resource_plural)
|
|
data = obj_lister(**search_opts)
|
|
return data
|
|
|
|
def retrieve_list(self, parsed_args):
|
|
"""Retrieve a list of resources from Tacker server"""
|
|
tacker_client = self.get_client()
|
|
tacker_client.format = parsed_args.request_format
|
|
_extra_values = parse_args_to_dict(self.values_specs)
|
|
_merge_args(self, parsed_args, _extra_values,
|
|
self.values_specs)
|
|
search_opts = self.args2search_opts(parsed_args)
|
|
search_opts.update(_extra_values)
|
|
if self.pagination_support:
|
|
page_size = parsed_args.page_size
|
|
if page_size:
|
|
search_opts.update({'limit': page_size})
|
|
if self.sorting_support:
|
|
keys = parsed_args.sort_key
|
|
if keys:
|
|
search_opts.update({'sort_key': keys})
|
|
dirs = parsed_args.sort_dir
|
|
len_diff = len(keys) - len(dirs)
|
|
if len_diff > 0:
|
|
dirs += ['asc'] * len_diff
|
|
elif len_diff < 0:
|
|
dirs = dirs[:len(keys)]
|
|
if dirs:
|
|
search_opts.update({'sort_dir': dirs})
|
|
data = self.call_server(tacker_client, search_opts, parsed_args)
|
|
collection = _get_resource_plural(self.resource, tacker_client)
|
|
return data.get(collection, [])
|
|
|
|
def extend_list(self, data, parsed_args):
|
|
"""Update a retrieved list.
|
|
|
|
This method provides a way to modify a original list returned from
|
|
the tacker server. For example, you can add subnet cidr information
|
|
to a list network.
|
|
"""
|
|
pass
|
|
|
|
def setup_columns(self, info, parsed_args):
|
|
_columns = len(info) > 0 and sorted(info[0].keys()) or []
|
|
if not _columns:
|
|
# clean the parsed_args.columns so that cliff will not break
|
|
parsed_args.columns = []
|
|
elif parsed_args.columns:
|
|
_columns = [x for x in parsed_args.columns if x in _columns]
|
|
elif self.list_columns:
|
|
# if no -c(s) by user and list_columns, we use columns in
|
|
# both list_columns and returned resource.
|
|
# Also Keep their order the same as in list_columns
|
|
_columns = [x for x in self.list_columns if x in _columns]
|
|
return (_columns, (utils.get_item_properties(
|
|
s, _columns, formatters=self._formatters, )
|
|
for s in info), )
|
|
|
|
def get_data(self, parsed_args):
|
|
self.log.debug('get_data(%s)', parsed_args)
|
|
data = self.retrieve_list(parsed_args)
|
|
self.extend_list(data, parsed_args)
|
|
return self.setup_columns(data, parsed_args)
|
|
|
|
|
|
class ShowCommand(TackerCommand, show.ShowOne):
|
|
"""Show information of a given resource
|
|
|
|
"""
|
|
|
|
api = 'nfv-orchestration'
|
|
resource = None
|
|
log = None
|
|
allow_names = True
|
|
|
|
def get_id(self):
|
|
if self.resource:
|
|
return self.resource.upper()
|
|
|
|
def get_parser(self, prog_name):
|
|
parser = super(ShowCommand, self).get_parser(prog_name)
|
|
add_show_list_common_argument(parser)
|
|
if self.allow_names:
|
|
help_str = _('ID or name of %s to look up')
|
|
else:
|
|
help_str = _('ID of %s to look up')
|
|
parser.add_argument(
|
|
'id', metavar=self.get_id(),
|
|
help=help_str % self.resource)
|
|
return parser
|
|
|
|
def get_data(self, parsed_args):
|
|
self.log.debug('get_data(%s)', parsed_args)
|
|
tacker_client = self.get_client()
|
|
tacker_client.format = parsed_args.request_format
|
|
|
|
params = {}
|
|
if parsed_args.show_details:
|
|
params = {'verbose': 'True'}
|
|
if parsed_args.fields:
|
|
params = {'fields': parsed_args.fields}
|
|
if self.allow_names:
|
|
_id = find_resourceid_by_name_or_id(tacker_client, self.resource,
|
|
parsed_args.id)
|
|
else:
|
|
_id = parsed_args.id
|
|
|
|
obj_shower = getattr(tacker_client, "show_%s" % self.resource)
|
|
data = obj_shower(_id, **params)
|
|
self.format_output_data(data)
|
|
resource = data[self.resource]
|
|
if self.resource in data:
|
|
return zip(*sorted(resource.items()))
|
|
else:
|
|
return None
|