def get_data(self, parsed_args):
self.log.debug('get_data(%s)' % parsed_args)
quantum_client = self.app.client_manager.quantum
search_opts = {
'tenant': parsed_args.tenant_id, }
for net_filter in net_filters_v11_opt:
option_key = net_filter.keys()[0]
arg = option_key[2:]
arg = arg.replace('-', '_')
arg_value = getattr(parsed_args, arg, None)
if arg_value is not None:
search_opts.update({option_key[2:]: arg_value, })
self.log.debug('search options: %s', search_opts)
quantum_client.format = parsed_args.request_format
columns = ('ID', )
data = None
if parsed_args.show_details:
data = quantum_client.list_networks_details(**search_opts)
# dict: {u'networks': [{u'op-status': u'UP',
# u'id': u'7a068b68-c736-42ab-9e43-c9d83c57627e',
# u'name': u'private'}]}
columns = ('ID', 'op-status', 'name', )
else:
data = quantum_client.list_networks(**search_opts)
# {u'networks': [{u'id':
# u'7a068b68-c736-42ab-9e43-c9d83c57627e'}]}
networks = []
if 'networks' in data:
networks = data['networks']
return (columns,
(utils.get_item_properties(
s, columns, formatters={}, ) for s in networks), )
def get_data(self, parsed_args):
self.log.debug('get_data(%s)' % parsed_args)
quantum_client = self.get_client()
search_opts = parse_args_to_dict(parsed_args.filter_specs)
self.log.debug('search options: %s', search_opts)
quantum_client.format = parsed_args.request_format
fields = parsed_args.fields
extra_fields = search_opts.get('fields', [])
if extra_fields:
if isinstance(extra_fields, list):
fields.extend(extra_fields)
else:
fields.append(extra_fields)
if fields:
search_opts.update({'fields': fields})
if parsed_args.show_details:
search_opts.update({'verbose': 'True'})
obj_lister = getattr(quantum_client,
"list_%ss" % self.resource)
data = obj_lister(**search_opts)
info = []
collection = self.resource + "s"
if collection in data:
info = data[collection]
_columns = len(info) > 0 and sorted(info[0].keys()) or []
return (_columns, (utils.get_item_properties(
s, _columns, formatters=self._formatters, )
for s in info), )
def get_data(self, parsed_args):
debug_agent = self.get_debug_agent()
info = debug_agent.list_probes()
columns = len(info) > 0 and sorted(info[0].keys()) or []
return (columns, (utils.get_item_properties(
s, columns, formatters=self._formatters, )
for s in info), )
def test_get_object_item_desired_fields_is_empty(self):
class Fake(object):
def __init__(self):
self.id = 'test_id_1'
self.name = 'test_name'
self.test_user = '******'
fields = []
item = Fake()
actual = utils.get_item_properties(item, fields)
self.assertEqual((), actual)
def test_get_object_item_desired_fields_differ_from_item(self):
class Fake(object):
def __init__(self):
self.id = 'test_id_1'
self.name = 'test_name'
self.test_user = '******'
fields = ('name', 'id', 'test user')
item = Fake()
actual = utils.get_item_properties(item, fields)
self.assertNotEqual(('test_name', 'test_id', 'test'), actual)
def test_get_object_item_properties_mixed_case_fields(self):
class Fake(object):
def __init__(self):
self.id = 'test_id'
self.name = 'test_name'
self.test_user = '******'
fields = ('name', 'id', 'test user')
mixed_fields = ('test user', 'ID')
item = Fake()
actual = utils.get_item_properties(item, fields, mixed_fields)
self.assertEqual(('test_name', 'test_id', 'test'), actual)
def get_data(self, parsed_args):
debug_agent = self.get_debug_agent()
info = debug_agent.list_probes()
columns = len(info) > 0 and sorted(info[0].keys()) or []
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)
quantum_client = self.get_client()
search_opts = {}
quantum_client.format = parsed_args.request_format
obj_lister = getattr(quantum_client, "list_%ss" % self.resource)
data = obj_lister(**search_opts)
info = []
collection = self.resource + "s"
if collection in data:
info = data[collection]
_columns = len(info) > 0 and sorted(info[0].keys()) or []
return (_columns, (utils.get_item_properties(s, _columns) for s in info))
def get_data(self, parsed_args):
self.log.debug('get_data(%s)' % parsed_args)
quantum_client = self.get_client()
search_opts = {}
quantum_client.format = parsed_args.request_format
obj_lister = getattr(quantum_client, "list_%ss" % self.resource)
data = obj_lister(**search_opts)
info = []
collection = self.resource + "s"
if collection in data:
info = data[collection]
_columns = len(info) > 0 and sorted(info[0].keys()) or []
return (_columns, (utils.get_item_properties(s, _columns)
for s in info))
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 test_get_object_item_with_formatters(self):
class Fake(object):
def __init__(self):
self.id = 'test_id'
self.name = 'test_name'
self.test_user = '******'
class FakeCallable(object):
def __call__(self, *args, **kwargs):
return 'pass'
fields = ('name', 'id', 'test user', 'is_public')
formatters = {'is_public': FakeCallable()}
item = Fake()
act = utils.get_item_properties(item, fields, formatters=formatters)
self.assertEqual(('test_name', 'test_id', 'test', 'pass'), act)
def get_data(self, parsed_args):
self.log.debug('get_data(%s)' % parsed_args)
quantum_client = self.get_client()
search_opts = parse_args_to_dict(parsed_args.filter_specs)
self.log.debug('search options: %s', search_opts)
quantum_client.format = parsed_args.request_format
fields = parsed_args.fields
extra_fields = search_opts.get('fields', [])
if extra_fields:
if isinstance(extra_fields, list):
fields.extend(extra_fields)
else:
fields.append(extra_fields)
if fields:
search_opts.update({'fields': fields})
if parsed_args.show_details:
search_opts.update({'verbose': 'True'})
obj_lister = getattr(quantum_client, "list_%ss" % self.resource)
data = obj_lister(**search_opts)
info = []
collection = self.resource + "s"
if collection in data:
info = data[collection]
_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 not parsed_args.columns and 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)
quantum_client = self.get_client()
search_opts = parse_args_to_dict(parsed_args.filter_specs)
self.log.debug('search options: %s', search_opts)
quantum_client.format = parsed_args.request_format
fields = parsed_args.fields
extra_fields = search_opts.get('fields', [])
if extra_fields:
if isinstance(extra_fields, list):
fields.extend(extra_fields)
else:
fields.append(extra_fields)
if fields:
search_opts.update({'fields': fields})
if parsed_args.show_details:
search_opts.update({'verbose': 'True'})
obj_lister = getattr(quantum_client,
"list_%ss" % self.resource)
data = obj_lister(**search_opts)
info = []
collection = self.resource + "s"
if collection in data:
info = data[collection]
_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 not parsed_args.columns and 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)
quantum_client = self.get_client()
quantum_client.format = parsed_args.request_format
params = {}
if parsed_args.show_details:
params = {'verbose': 'True'}
if parsed_args.fields:
params = {'fields': parsed_args.fields}
data = None
# Error message to be used in case both search by id and name are
# unsuccessful (if list by name fails it does not return an error)
not_found_message = "Unable to find resource:%s" % parsed_args.id
# perform search by id only if we are passing a valid UUID
match = re.match(self.UUID_PATTERN, parsed_args.id)
if match:
try:
obj_shower = getattr(quantum_client,
"show_%s" % self.resource)
data = obj_shower(parsed_args.id, **params)
except exceptions.QuantumClientException as ex:
logging.debug("Show operation failed with code:%s",
ex.status_code)
not_found_message = ex.message
if ex.status_code != 404:
logging.exception("Unable to perform show operation")
raise
# If data is empty, then we got a 404. Try to interpret Id as a name
if not data:
logging.debug("Trying to interpret %s as a %s name",
parsed_args.id,
self.resource)
# build search_opts for the name
search_opts = parse_args_to_dict(["--name=%s" % parsed_args.id])
search_opts.update(params)
obj_lister = getattr(quantum_client,
"list_%ss" % self.resource)
data = obj_lister(**search_opts)
info = []
collection = self.resource + "s"
if collection in data:
info = data[collection]
if len(info) > 1:
logging.info("Multiple occurrences found for: %s",
parsed_args.id)
_columns = ['id']
# put all ids in a single string as formatter for show
# command will print on record only
id_string = "\n".join(utils.get_item_properties(
s, _columns)[0] for s in info)
return (_columns, (id_string, ), )
elif len(info) == 0:
#Nothing was found
raise exceptions.QuantumClientException(
message=not_found_message)
else:
data = {self.resource: info[0]}
if self.resource in data:
for k, v in data[self.resource].iteritems():
if isinstance(v, list):
value = ""
for _item in v:
if value:
value += "\n"
if isinstance(_item, dict):
value += utils.dumps(_item)
else:
value += str(_item)
data[self.resource][k] = value
elif v is None:
data[self.resource][k] = ''
return zip(*sorted(data[self.resource].iteritems()))
else:
return None
def test_get_dict_item_properties(self):
item = {'name': 'test_name', 'id': 'test_id'}
fields = ('name', 'id')
actual = utils.get_item_properties(item=item, fields=fields)
self.assertEqual(('test_name', 'test_id'), actual)
def get_data(self, parsed_args):
self.log.debug('get_data(%s)' % parsed_args)
quantum_client = self.app.client_manager.quantum
quantum_client.tenant = parsed_args.tenant_id
quantum_client.format = parsed_args.request_format
data = None
if parsed_args.show_details:
data = quantum_client.show_network_details(parsed_args.net_id)
else:
data = quantum_client.show_network(parsed_args.net_id)
# {u'network': {u'op-status': u'UP', 'xmlns':
# u'http://openstack.org/quantum/api/v1.1', u'id':
# u'7a068b68-c736-42ab-9e43-c9d83c57627e', u'name': u'private'}}
network = {}
ports = None
network = 'network' in data and data['network'] or None
if network:
ports = network.pop('ports', None)
column_names, data = zip(*sorted(network.iteritems()))
if not parsed_args.columns:
columns_to_include = column_names
else:
columns_to_include = [c for c in column_names
if c in parsed_args.columns]
# Set up argument to compress()
selector = [(c in columns_to_include)
for c in column_names]
data = list(itertools.compress(data, selector))
formatter = self.formatters[parsed_args.formatter]
formatter.emit_one(columns_to_include, data,
self.app.stdout, parsed_args)
if ports:
print >>self.app.stdout, _('Network Ports:')
columns = ('op-status', 'state', 'id', 'attachment', )
column_names, data = (columns, (utils.get_item_properties(
s, columns, formatters={'attachment': _format_attachment}, )
for s in ports), )
if not parsed_args.columns:
columns_to_include = column_names
data_gen = data
else:
columns_to_include = [c for c in column_names
if c in parsed_args.columns]
if not columns_to_include:
raise ValueError(
'No recognized column names in %s' %
str(parsed_args.columns))
# Set up argument to compress()
selector = [(c in columns_to_include)
for c in column_names]
# Generator expression to only return the parts of a row
# of data that the user has expressed interest in
# seeing. We have to convert the compress() output to a
# list so the table formatter can ask for its length.
data_gen = (list(itertools.compress(row, selector))
for row in data)
formatter = self.formatters[parsed_args.formatter]
formatter.emit_list(columns_to_include,
data_gen, self.app.stdout, parsed_args)
return ('', [])
