def take_action(self, parsed_args):
if parsed_args.long:
columns = ('Zone Name', 'Zone Status', 'Zone Resource',
'Host Name', 'Service Name', 'Service Status')
else:
columns = ('Zone Name', 'Zone Status')
# Show everything by default.
show_all = (not parsed_args.compute and
not parsed_args.volume and
not parsed_args.network)
result = []
if parsed_args.compute or show_all:
result += self._get_compute_availability_zones(parsed_args)
if parsed_args.volume or show_all:
result += self._get_volume_availability_zones(parsed_args)
if parsed_args.network or show_all:
result += self._get_network_availability_zones(parsed_args)
return (columns,
(utils.get_dict_properties(
s, columns
) for s in result))
def _get_detailed_quotas(self, parsed_args):
columns = (
'resource',
'in_use',
'reserved',
'limit'
)
column_headers = (
'Resource',
'In Use',
'Reserved',
'Limit'
)
quotas = {}
if parsed_args.compute:
quotas.update(self.get_compute_quota(
self.app.client_manager.compute, parsed_args))
if parsed_args.network:
quotas.update(self.get_network_quota(parsed_args))
result = []
for resource, values in quotas.items():
# NOTE(slaweq): there is no detailed quotas info for some resources
# and it should't be displayed here
if type(values) is dict:
result.append({
'resource': resource,
'in_use': values.get('in_use'),
'reserved': values.get('reserved'),
'limit': values.get('limit')
})
return (column_headers,
(utils.get_dict_properties(
s, columns,
) for s in result))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
ppg_id = _get_id(client, parsed_args.port_pair_group, resource)
obj = client.show_sfc_port_pair_group(ppg_id)[resource]
columns, display_columns = nc_osc_utils.get_columns(obj, _attr_map)
data = utils.get_dict_properties(obj, columns)
return display_columns, data
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.messaging
flavor_data = client.flavor(parsed_args.flavor_name,
auto_create=False).get()
columns = ('Name', 'Pool Group', 'Capabilities')
return columns, utils.get_dict_properties(flavor_data, columns)
def take_action(self, parsed_args):
client = _get_client(self, parsed_args)
pool_data = client.pool(parsed_args.pool_name,
auto_create=False).get()
columns = ('Name', 'Weight', 'URI', 'Group', 'Options')
return columns, utils.get_dict_properties(pool_data, columns)
def take_action(self, parsed_args):
if parsed_args.long:
columns = ('Name', 'Bytes', 'Count')
else:
columns = ('Name',)
kwargs = {}
if parsed_args.prefix:
kwargs['prefix'] = parsed_args.prefix
if parsed_args.marker:
kwargs['marker'] = parsed_args.marker
if parsed_args.end_marker:
kwargs['end_marker'] = parsed_args.end_marker
if parsed_args.limit:
kwargs['limit'] = parsed_args.limit
if parsed_args.all:
kwargs['full_listing'] = True
data = self.app.client_manager.object_store.container_list(
**kwargs
)
return (columns,
(utils.get_dict_properties(
s, columns,
formatters={},
) for s in data))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
obj = client.list_fwaas_firewall_groups()[const.FWGS]
headers, columns = column_util.get_column_definitions(
_attr_map, long_listing=parsed_args.long)
return (headers, (utils.get_dict_properties(
s, columns, formatters=_formatters) for s in obj))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
attrs = {}
if parsed_args.name is not None:
attrs['name'] = str(parsed_args.name)
if parsed_args.type is not None:
attrs['type'] = parsed_args.type
if parsed_args.route_targets is not None:
attrs['route_targets'] = parsed_args.route_targets
if parsed_args.import_targets is not None:
attrs['import_targets'] = parsed_args.import_targets
if parsed_args.export_targets is not None:
attrs['export_targets'] = parsed_args.export_targets
if parsed_args.route_distinguishers is not None:
attrs['route_distinguishers'] = parsed_args.route_distinguishers
if parsed_args.vni is not None:
attrs['vni'] = parsed_args.vni
if parsed_args.local_pref is not None:
attrs['local_pref'] = parsed_args.local_pref
if 'project' in parsed_args and parsed_args.project is not None:
project_id = nc_osc_utils.find_project(
self.app.client_manager.identity,
parsed_args.project,
parsed_args.project_domain,
).id
attrs['tenant_id'] = project_id
body = {constants.BGPVPN: attrs}
obj = client.create_bgpvpn(body)[constants.BGPVPN]
columns, display_columns = column_util.get_columns(obj, _attr_map)
data = osc_utils.get_dict_properties(obj, columns,
formatters=_formatters)
return display_columns, data
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
search_client = self.app.client_manager.search
columns = (
"Resource Type",
"Type",
"Name",
"Options"
)
params = {
"type": parsed_args.type,
"limit_terms": parsed_args.limit_terms,
"all_projects": parsed_args.all_projects
}
data = search_client.facets.list(**params)
result = []
for resource_type, values in data.items():
if isinstance(values, list):
# Cope with pre-1.0 service APIs
facets = values
else:
facets = values['facets']
for s in facets:
options = []
for o in s.get('options', []):
options.append(
str(o['key']) + '(' + str(o['doc_count']) + ')')
s["options"] = ', '.join(options)
s["resource_type"] = resource_type
result.append(utils.get_dict_properties(s, columns))
return (columns, result)
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
create_method = getattr(
client, 'create_bgpvpn_%s_assoc' % self._assoc_res_name)
bgpvpn = client.find_resource(constants.BGPVPN, parsed_args.bgpvpn)
assoc_res = client.find_resource(self._assoc_res_name,
parsed_args.resource)
body = {
self._resource: {
'%s_id' % self._assoc_res_name: assoc_res['id'],
},
}
if 'project' in parsed_args and parsed_args.project is not None:
project_id = nc_osc_utils.find_project(
self.app.client_manager.identity,
parsed_args.project,
parsed_args.project_domain,
).id
body[self._resource]['tenant_id'] = project_id
arg2body = getattr(self, '_args2body', None)
if callable(arg2body):
body[self._resource].update(
arg2body(bgpvpn['id'], parsed_args)[self._resource])
obj = create_method(bgpvpn['id'], body)[self._resource]
transform = getattr(self, '_transform_resource', None)
if callable(transform):
transform(obj)
columns, display_columns = nc_osc_utils.get_columns(obj,
self._attr_map)
data = osc_utils.get_dict_properties(obj, columns,
formatters=self._formatters)
return display_columns, data
def _show_config(heat_client, config_id, config_only):
try:
sc = heat_client.software_configs.get(config_id=config_id)
except heat_exc.HTTPNotFound:
raise exc.CommandError(_('Configuration not found: %s') % config_id)
columns = None
rows = None
if config_only:
print(sc.config)
else:
columns = (
'id',
'name',
'group',
'config',
'inputs',
'outputs',
'options',
'creation_time',
)
rows = utils.get_dict_properties(sc.to_dict(), columns)
return columns, rows
def _test_get_dict_properties_with_formatter(self, formatters):
names = ('id', 'attr')
item = {'id': 'fake-id', 'attr': ['a', 'b']}
res_id, res_attr = utils.get_dict_properties(item, names,
formatters=formatters)
self.assertEqual('fake-id', res_id)
return res_attr
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
data = client.list_trunks()
headers = (
'ID',
'Name',
'Parent Port',
'Description'
)
columns = (
'id',
'name',
'port_id',
'description'
)
if parsed_args.long:
headers += (
'Status',
'State',
'Created At',
'Updated At',
)
columns += (
'status',
'admin_state_up',
'created_at',
'updated_at'
)
return (headers,
(osc_utils.get_dict_properties(
s, columns,
formatters=_formatters,
) for s in data[TRUNKS]))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
attrs = _get_common_attrs(self.app.client_manager, parsed_args)
obj = client.create_network_log({'log': attrs})['log']
columns, display_columns = osc_utils.get_columns(obj, _attr_map)
data = utils.get_dict_properties(obj, columns)
return (display_columns, data)
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
attrs = _get_common_attrs(self.app.client_manager, parsed_args)
obj = common.create_sfc_resource(self, client, resource, attrs)
columns = common.get_columns(obj[resource])
data = utils.get_dict_properties(obj[resource], columns)
return columns, data
def take_action(self, parsed_args):
if parsed_args.name:
if len(parsed_args.objects) > 1:
msg = _('Attempting to upload multiple objects and '
'using --name is not permitted')
raise exceptions.CommandError(msg)
results = []
for obj in parsed_args.objects:
if len(obj) > 1024:
LOG.warning(
_('Object name is %s characters long, default limit'
' is 1024'), len(obj))
data = self.app.client_manager.object_store.object_create(
container=parsed_args.container,
object=obj,
name=parsed_args.name,
)
results.append(data)
columns = ("object", "container", "etag")
return (columns,
(utils.get_dict_properties(
s, columns,
formatters={},
) for s in results))
def take_action(self, parsed_args):
client = _get_client(self, parsed_args)
kwargs = {'id': parsed_args.subscription_id}
pool_data = client.subscription(parsed_args.queue_name,
**kwargs)
columns = ('ID', 'Subscriber', 'TTL', 'Age', 'Confirmed', 'Options')
return columns, utils.get_dict_properties(pool_data.__dict__, columns)
def take_action(self, parsed_args):
client = self.app.client_manager.tackerclient
_params = {}
if parsed_args.nfp_id:
_params['nfp_id'] = parsed_args.nfp_id
if parsed_args.tenant_id:
_params['tenant_id'] = parsed_args.tenant_id
classifiers = client.list('classifiers', fcs_path, True,
**_params)
for classifier in classifiers['classifiers']:
error_reason = classifier.get('error_reason', None)
if error_reason and \
len(error_reason) > DEFAULT_ERROR_REASON_LENGTH:
classifier['error_reason'] = error_reason[
:DEFAULT_ERROR_REASON_LENGTH]
classifier['error_reason'] += '...'
data = {}
data['classifiers'] = classifiers['classifiers']
data = client.list_classifiers()
headers, columns = tacker_osc_utils.get_column_definitions(
_attr_map_fc, long_listing=None)
return (headers,
(utils.get_dict_properties(
s, columns,
) for s in data[_FC + 's']))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
fc_id = _get_id(client, parsed_args.flow_classifier, resource)
obj = client.show_sfc_flow_classifier(fc_id)[resource]
columns, display_columns = nc_osc_utils.get_columns(obj, _attr_map)
data = utils.get_dict_properties(obj, columns)
return display_columns, data
def take_action(self, parsed_args):
client = self.app.client_manager.tackerclient
_params = {}
if parsed_args.vim_id:
_params['vim_id'] = parsed_args.vim_id
if parsed_args.vim_name:
vim_id = tackerV10.find_resourceid_by_name_or_id(
client, 'vim', parsed_args.vim_name
)
_params['vim_id'] = vim_id
if parsed_args.vnfd_id:
_params['vnfd_id'] = parsed_args.vnfd_id
if parsed_args.vnfd_name:
vim_id = tackerV10.find_resourceid_by_name_or_id(
client, 'vnfd', parsed_args.vnfd_name
)
_params['vnfd_id'] = vim_id
if parsed_args.tenant_id:
_params['tenant_id'] = parsed_args.tenant_id
data = client.list_vnfs(**_params)
headers, columns = tacker_osc_utils.get_column_definitions(
_attr_map, long_listing=parsed_args.long)
return (headers,
(utils.get_dict_properties(
s, columns,
) for s in data[_VNF + 's']))
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
qos_specs_list = volume_client.qos_specs.list()
for qos in qos_specs_list:
try:
qos_associations = volume_client.qos_specs.get_associations(
qos,
)
if qos_associations:
associations = [
association.name for association in qos_associations
]
qos._info.update({'associations': associations})
except Exception as ex:
if type(ex).__name__ == 'NotFound':
qos._info.update({'associations': None})
else:
raise
display_columns = (
'ID', 'Name', 'Consumer', 'Associations', 'Properties')
columns = ('ID', 'Name', 'Consumer', 'Associations', 'Specs')
return (display_columns,
(utils.get_dict_properties(
s._info, columns,
formatters={
'Specs': utils.format_dict,
'Associations': utils.format_list
},
) for s in qos_specs_list))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
sg_id = _get_id(client, parsed_args.service_graph, resource)
obj = client.show_sfc_service_graph(sg_id)[resource]
columns, display_columns = column_util.get_columns(obj, _attr_map)
data = utils.get_dict_properties(obj, columns)
return display_columns, data
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
obj = client.list_ipsec_site_connections()['ipsec_site_connections']
headers, columns = osc_utils.get_column_definitions(
_attr_map, long_listing=parsed_args.long)
return (headers, (utils.get_dict_properties(
s, columns, formatters=_formatters) for s in obj))
def take_action(self, parsed_args):
data = self.app.client_manager.neutronclient.list_bgp_peers()
headers = ('ID', 'Name', 'Peer IP', 'Remote AS')
columns = ('id', 'name', 'peer_ip', 'remote_as')
return (headers,
(utils.get_dict_properties(
s, columns,
) for s in data[constants.BGP_PEERS]))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
attrs = _get_attrs(self.app.client_manager, parsed_args)
body = {constants.BGP_PEER: attrs}
obj = client.create_bgp_peer(body)[constants.BGP_PEER]
columns, display_columns = column_util.get_columns(obj)
data = utils.get_dict_properties(obj, columns)
return display_columns, data
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
data = client.list_sfc_service_graphs()
headers, columns = column_util.get_column_definitions(
_attr_map, long_listing=parsed_args.long)
return (headers,
(utils.get_dict_properties(s, columns)
for s in data['service_graphs']))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
attrs = _get_common_attrs(self.app.client_manager, parsed_args)
body = {resource: attrs}
obj = client.create_sfc_flow_classifier(body)[resource]
columns, display_columns = nc_osc_utils.get_columns(obj, _attr_map)
data = utils.get_dict_properties(obj, columns)
return display_columns, data
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
trunk_id = _get_id(client, parsed_args.trunk, TRUNK)
obj = client.show_trunk(trunk_id)
columns = _get_columns(obj[TRUNK])
data = osc_utils.get_dict_properties(obj[TRUNK], columns,
formatters=_formatters)
return columns, data
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
obj = client.list_sfc_flow_classifiers()
obj_extend = self.extend_list(obj, parsed_args)
headers, columns = nc_osc_utils.get_column_definitions(
_attr_map, long_listing=parsed_args.long)
return (headers, (utils.get_dict_properties(
s, columns) for s in obj_extend))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
id = client.find_resource(constants.BGP_SPEAKER,
parsed_args.bgp_speaker)['id']
obj = client.show_bgp_speaker(id)[constants.BGP_SPEAKER]
columns, display_columns = column_util.get_columns(obj)
data = utils.get_dict_properties(obj, columns)
return display_columns, data
def setUp(self):
super(TestShareGroupList, self).setUp()
self.new_share_group = (
manila_fakes.FakeShareGroup.create_one_share_group())
self.groups_mock.list.return_value = [self.new_share_group]
self.share_group = (
manila_fakes.FakeShareGroup.create_one_share_group())
self.groups_mock.get.return_value = self.share_group
self.share_groups_list = (
manila_fakes.FakeShareGroup.create_share_groups(count=2))
self.groups_mock.list.return_value = self.share_groups_list
self.values = (oscutils.get_dict_properties(s._info, self.columns)
for s in self.share_groups_list)
self.cmd = osc_share_groups.ListShareGroup(self.app, None)
def take_action(self, parsed_args):
# Hide tenant_id for now, the value incorrect in the
# plugin implementation
invisible_columns = ('tenant_id', )
client = self.app.client_manager.nuageclient
# At this time client.find_resource is implemented using list instead
# of show, that's why we have to do two calls. Once this is fixed
# upstream we can reduce the number of calls
netpartition_id = client.find_net_partition(
name_or_id=parsed_args.nuage_netpartition)['id']
item = client.show_net_partition(netpartition_id)['net_partition']
column_getter = sdk_utils.get_osc_show_columns_for_sdk_resource
osc_column_map = {k: v for v, k, _ in _attr_map}
columns, display_columns = column_getter(item, osc_column_map,
invisible_columns)
return display_columns, utils.get_dict_properties(item, columns)
def take_action_compute(self, client, parsed_args):
search = {'all_tenants': parsed_args.all_projects}
data = client.api.security_group_list(
# TODO(dtroyer): add limit, marker
search_opts=search, )
columns = (
"ID",
"Name",
"Description",
)
column_headers = columns
if parsed_args.all_projects:
columns = columns + ('Tenant ID', )
column_headers = column_headers + ('Project', )
return (column_headers, (utils.get_dict_properties(
s,
columns,
) for s in data))
def take_action_network(self, client, parsed_args):
column_headers = self._get_column_headers(parsed_args)
columns = (
'id',
'protocol',
'ether_type',
'remote_ip_prefix',
'port_range',
)
if parsed_args.long:
columns = columns + ('direction',)
columns = columns + ('remote_group_id',)
# Get the security group rules using the requested query.
query = {}
if parsed_args.group is not None:
# NOTE(rtheis): Unfortunately, the security group resource
# does not contain security group rules resources. So use
# the security group ID in a query to get the resources.
security_group_id = client.find_security_group(
parsed_args.group,
ignore_missing=False
).id
query = {'security_group_id': security_group_id}
else:
columns = columns + ('security_group_id',)
if parsed_args.ingress:
query['direction'] = 'ingress'
if parsed_args.egress:
query['direction'] = 'egress'
if parsed_args.protocol is not None:
query['protocol'] = parsed_args.protocol
rules = [
self._format_network_security_group_rule(r)
for r in client.security_group_rules(**query)
]
return (column_headers,
(utils.get_dict_properties(
s, columns,
) for s in rules))
def take_action(self, parsed_args):
rows = const.FLAVORPROFILE_ROWS
data = None
if uuidutils.is_uuid_like(parsed_args.flavorprofile):
try:
data = (
self.app.client_manager.load_balancer.flavorprofile_show(
flavorprofile_id=parsed_args.flavorprofile))
except exceptions.NotFound:
pass
if data is None:
attrs = v2_utils.get_flavorprofile_attrs(self.app.client_manager,
parsed_args)
flavorprofile_id = attrs.pop('flavorprofile_id')
data = self.app.client_manager.load_balancer.flavorprofile_show(
flavorprofile_id=flavorprofile_id)
return (rows, (utils.get_dict_properties(data, rows, formatters={})))
def take_action(self, parsed_args):
rows = const.LOAD_BALANCER_ROWS
attrs = v2_utils.get_loadbalancer_attrs(self.app.client_manager,
parsed_args)
self._check_attrs(attrs)
body = {'loadbalancer': attrs}
data = self.app.client_manager.load_balancer.load_balancer_create(
json=body)
formatters = {
'listeners': v2_utils.format_list,
'pools': v2_utils.format_list,
'l7policies': v2_utils.format_list
}
return (rows,
(utils.get_dict_properties(
data['loadbalancer'], rows, formatters=formatters)))
def take_action(self, parsed_args):
client = self.app.client_manager.nuageclient
project_id = self._find_project_id(parsed_args.project)
try:
obj = client.show_project_netpartition_mapping(
project_id)[RESOURCE_NAME]
except neutron_exc.NotFound:
raise neutron_exc.NotFound('No Project netpartition '
'mapping was found for Project '
'{}.'.format(parsed_args.project))
try:
obj['net_partition_name'] = client.show_net_partition(
obj['net_partition_id'])['net_partition']['name']
except neutron_exc.NotFound:
pass
columns, display_columns = column_util.get_columns(obj, _attr_map)
data = utils.get_dict_properties(obj, columns)
return display_columns, data
def take_action(self, parsed_args):
search_opts = {}
client = self.app.client_manager.neutronclient
if parsed_args.bgp_speaker is not None:
search_opts = {}
speaker_id = client.find_resource(constants.BGP_SPEAKER,
parsed_args.bgp_speaker)['id']
search_opts['bgp_speaker'] = speaker_id
data = client.list_dragents_hosting_bgp_speaker(**search_opts)
else:
attrs = {'agent_type': 'BGP dynamic routing agent'}
data = client.list_agents(**attrs)
headers = ('ID', 'Host', 'State', 'Alive')
columns = ('id', 'host', 'admin_state_up', 'alive')
return (headers, (utils.get_dict_properties(
s,
columns,
formatters=_formatters,
) for s in data['agents']))
def _show_action(senlin_client, action_id):
try:
action = senlin_client.get_action(action_id)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_('Action not found: %s') % action_id)
formatters = {
'inputs': senlin_utils.json_formatter,
'outputs': senlin_utils.json_formatter,
'metadata': senlin_utils.json_formatter,
'data': senlin_utils.json_formatter,
'depends_on': senlin_utils.list_formatter,
'depended_by': senlin_utils.list_formatter,
}
data = action.to_dict()
columns = sorted(data.keys())
return columns, utils.get_dict_properties(data,
columns,
formatters=formatters)
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
client = self.app.client_manager.orchestration
try:
outputs = client.stacks.output_list(parsed_args.stack)['outputs']
except heat_exc.HTTPNotFound:
try:
outputs = client.stacks.get(
parsed_args.stack).to_dict()['outputs']
except heat_exc.HTTPNotFound:
msg = _('Stack not found: %s') % parsed_args.stack
raise exc.CommandError(msg)
columns = ['output_key', 'description']
return (columns, (utils.get_dict_properties(s, columns)
for s in outputs))
def take_action(self, parsed_args):
results = []
for container in parsed_args.containers:
if len(container) > 256:
LOG.warning(
_('Container name is %s characters long, the default limit'
' is 256'), len(container))
data = self.app.client_manager.object_store.container_create(
container=container,
)
results.append(data)
columns = ("account", "container", "x-trans-id")
return (columns,
(utils.get_dict_properties(
s, columns,
formatters={},
) for s in results))
def take_action(self, parsed_args):
rows = const.LISTENER_ROWS
attrs = v2_utils.get_listener_attrs(self.app.client_manager,
parsed_args)
listener_id = attrs.pop('listener_id')
data = self.app.client_manager.load_balancer.listener_show(
listener_id=listener_id, )
formatters = {
'loadbalancers': v2_utils.format_list,
'pools': v2_utils.format_list,
'l7policies': v2_utils.format_list,
'insert_headers': v2_utils.format_hash
}
return rows, utils.get_dict_properties(data,
rows,
formatters=formatters)
def setUp(self):
super(TestShareAccessList, self).setUp()
self.share = manila_fakes.FakeShare.create_one_share()
self.access_rule_1 = (
manila_fakes.FakeShareAccessRule.create_one_access_rule(
attrs={"share_id": self.share.id}))
self.access_rule_2 = (
manila_fakes.FakeShareAccessRule.create_one_access_rule(
attrs={"share_id": self.share.id, "access_to": "admin"}))
self.access_rules = [self.access_rule_1, self.access_rule_2]
self.shares_mock.get.return_value = self.share
self.access_rules_mock.access_list.return_value = self.access_rules
self.values_list = (oscutils.get_dict_properties(
a._info, self.access_rules_columns) for a in self.access_rules)
# Get the command object to test
self.cmd = osc_share_access_rules.ListShareAccess(self.app, None)
def take_action_compute(self, client, parsed_args):
columns = (
'id',
'label',
'cidr',
)
column_headers = (
'ID',
'Name',
'Subnet',
)
data = client.api.network_list()
return (column_headers, (utils.get_dict_properties(
s,
columns,
formatters=_formatters,
) for s in data))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
params = {}
if parsed_args.project is not None:
project_id = nc_osc_utils.find_project(
self.app.client_manager.identity,
parsed_args.project,
parsed_args.project_domain,
).id
params['tenant_id'] = project_id
if parsed_args.property:
params.update(parsed_args.property)
objs = client.list_bgpvpns(**params)[constants.BGPVPNS]
headers, columns = nc_osc_utils.get_column_definitions(
_attr_map, long_listing=parsed_args.long)
return (headers, (osc_utils.get_dict_properties(s,
columns,
formatters=_formatters)
for s in objs))
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
baremetal_client = self.app.client_manager.baremetal
columns = res_fields.VENDOR_PASSTHRU_METHOD_RESOURCE.fields
labels = res_fields.VENDOR_PASSTHRU_METHOD_RESOURCE.labels
methods = baremetal_client.driver.get_vendor_passthru_methods(
parsed_args.driver)
params = []
for method, response in methods.items():
response['name'] = method
http_methods = ', '.join(response['http_methods'])
response['http_methods'] = http_methods
params.append(response)
return (labels, (oscutils.get_dict_properties(s, columns)
for s in params))
def take_action(self, parsed_args):
columns = const.AMPHORA_COLUMNS
attrs = v2_utils.get_amphora_attrs(self.app.client_manager,
parsed_args)
data = self.app.client_manager.load_balancer.amphora_list(**attrs)
formatters = {
'amphorae': v2_utils.format_list,
}
return (
columns,
(utils.get_dict_properties(
amp,
columns,
formatters=formatters,
) for amp in data['amphorae']),
)
def take_action(self, parsed_args):
http = self.app.client_manager.placement
data = {'name': parsed_args.name}
if 'uuid' in parsed_args and parsed_args.uuid:
data['uuid'] = parsed_args.uuid
if ('parent_provider' in parsed_args and parsed_args.parent_provider):
self.check_version(version.ge('1.14'))
data['parent_provider_uuid'] = parsed_args.parent_provider
resp = http.request('POST', BASE_URL, json=data)
resource = http.request('GET', resp.headers['Location']).json()
fields = ('uuid', 'name', 'generation')
if self.compare_version(version.ge('1.14')):
fields += ('root_provider_uuid', 'parent_provider_uuid')
return fields, utils.get_dict_properties(resource, fields)
def take_action(self, parsed_args):
attrs = {
'parameters': {},
}
# mandatory
attrs['vault_id'] = parsed_args.vault_id
# optional
if parsed_args.auto_trigger is not None:
attrs['parameters'].update(auto_trigger=parsed_args.auto_trigger)
if parsed_args.description:
attrs['parameters'].update(
description=parsed_args.description)
if parsed_args.no_incremental is not None:
attrs['parameters'].update(incremental=parsed_args.no_incremental)
if parsed_args.backup_name:
attrs['parameters'].update(
name=parsed_args.backup_name)
if parsed_args.resources:
attrs['parameters'].update(
resources=parsed_args.resources)
if parsed_args.resource_details:
attrs['parameters'].update(resource_details=_normalize_resources(
parsed_args.resource_details))
client = self.app.client_manager.cbr
obj = client.create_checkpoint(**attrs)
data = utils.get_dict_properties(
_flatten_checkpoint(obj), self.columns)
if obj.vault.resources:
data, self.columns = _add_resources_to_obj(obj, data, self.columns)
if obj.vault.skipped_resources:
data, self.columns = _add_skipped_resources_to_obj(obj, data,
self.columns)
return (self.columns, data)
def take_action(self, parsed_args):
rows = const.POOL_ROWS
attrs = v2_utils.get_pool_attrs(self.app.client_manager, parsed_args)
pool_id = attrs.pop('pool_id')
data = self.app.client_manager.load_balancer.pool_show(
pool_id=pool_id, )
formatters = {
'loadbalancers': v2_utils.format_list,
'members': v2_utils.format_list,
'listeners': v2_utils.format_list,
'session_persistence': v2_utils.format_hash
}
return (rows,
(utils.get_dict_properties(data,
rows,
formatters=formatters,
mixed_case_fields=['enable-tls'])))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
attrs = _get_common_attrs(self.app.client_manager, parsed_args)
if parsed_args.name:
attrs['name'] = str(parsed_args.name)
attrs['type'] = parsed_args.type
if parsed_args.type == 'subnet':
_subnet_ids = [client.find_resource(
'subnet',
endpoint,
cmd_resource='subnet')['id']
for endpoint in parsed_args.endpoints]
attrs['endpoints'] = _subnet_ids
else:
attrs['endpoints'] = parsed_args.endpoints
obj = client.create_endpoint_group(
{'endpoint_group': attrs})['endpoint_group']
columns, display_columns = column_util.get_columns(obj, _attr_map)
data = utils.get_dict_properties(obj, columns)
return display_columns, data
def _show_node(senlin_client, node_id, show_details=False):
"""Show detailed info about the specified node."""
try:
node = senlin_client.get_node(node_id, details=show_details)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_('Node not found: %s') % node_id)
formatters = {
'metadata': senlin_utils.json_formatter,
'data': senlin_utils.json_formatter,
'dependents': senlin_utils.json_formatter,
}
data = node.to_dict()
if show_details and data['details']:
formatters['details'] = senlin_utils.nested_dict_formatter(
list(data['details'].keys()), ['property', 'value'])
columns = sorted(data.keys())
return columns, utils.get_dict_properties(data, columns,
formatters=formatters)
def take_action(self, parsed_args):
share_client = self.app.client_manager.share
instance = osc_utils.find_resource(share_client.share_instances,
parsed_args.instance)
export_locations = share_client.share_instance_export_locations.list(
instance, search_opts=None)
columns = [
'ID',
'Path',
'Is Admin Only',
'Preferred',
]
data = (osc_utils.get_dict_properties(export_location._info, columns)
for export_location in export_locations)
return (columns, data)
def test_list_share_networks_detail(self):
values = (oscutils.get_dict_properties(
s._info, COLUMNS_DETAIL) for s in self.share_networks_list)
arglist = [
'--detail',
]
verifylist = [
('detail', True),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.share_networks_mock.list.assert_called_once_with(
search_opts=self.expected_search_opts)
self.assertEqual(COLUMNS_DETAIL, columns)
self.assertEqual(list(values), list(data))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
list_method = getattr(client,
'list_bgpvpn_%s_assocs' % self._assoc_res_name)
bgpvpn = client.find_resource(constants.BGPVPN, parsed_args.bgpvpn)
params = {}
if parsed_args.property:
params.update(parsed_args.property)
objs = list_method(bgpvpn['id'], retrieve_all=True,
**params)[self._resource_plural]
transform = getattr(self, '_transform_resource', None)
if callable(transform):
[transform(obj) for obj in objs]
headers, columns = column_util.get_column_definitions(
self._attr_map, long_listing=parsed_args.long)
return (headers,
(osc_utils.get_dict_properties(s,
columns,
formatters=self._formatters)
for s in objs))
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
qos_specs_list = volume_client.qos_specs.list()
for qos in qos_specs_list:
qos_associations = volume_client.qos_specs.get_associations(qos)
if qos_associations:
associations = [association.name
for association in qos_associations]
qos._info.update({'associations': associations})
columns = ('ID', 'Name', 'Consumer', 'Associations', 'Specs')
return (columns,
(utils.get_dict_properties(
s._info, columns,
formatters={
'Specs': utils.format_dict,
'Associations': utils.format_list
},
) for s in qos_specs_list))
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
heat_client = self.app.client_manager.orchestration
try:
data = heat_client.stacks.snapshot(parsed_args.stack,
parsed_args.name)
except heat_exc.HTTPNotFound:
raise exc.CommandError(_('Stack not found: %s')
% parsed_args.stack)
columns = [
'ID',
'name',
'status',
'status_reason',
'data',
'creation_time'
]
return (columns, utils.get_dict_properties(data, columns))
def take_action(self, parsed_args):
client = self.app.client_manager.neutronclient
attrs = _get_common_attrs(self.app.client_manager, parsed_args)
if parsed_args.vpnservice:
_vpnservice_id = client.find_resource(
'vpnservice',
parsed_args.vpnservice,
cmd_resource='vpnservice')['id']
attrs['vpnservice_id'] = _vpnservice_id
if parsed_args.ikepolicy:
_ikepolicy_id = client.find_resource(
'ikepolicy', parsed_args.ikepolicy,
cmd_resource='ikepolicy')['id']
attrs['ikepolicy_id'] = _ikepolicy_id
if parsed_args.ipsecpolicy:
_ipsecpolicy_id = client.find_resource(
'ipsecpolicy',
parsed_args.ipsecpolicy,
cmd_resource='ipsecpolicy')['id']
attrs['ipsecpolicy_id'] = _ipsecpolicy_id
if parsed_args.peer_id:
attrs['peer_id'] = parsed_args.peer_id
if parsed_args.peer_address:
attrs['peer_address'] = parsed_args.peer_address
if parsed_args.psk:
attrs['psk'] = parsed_args.psk
if parsed_args.name:
attrs['name'] = parsed_args.name
if (bool(parsed_args.local_endpoint_group) != bool(
parsed_args.peer_endpoint_group)):
message = _("You must specify both local and peer endpoint "
"groups")
raise exceptions.CommandError(message)
if not parsed_args.peer_cidrs and not parsed_args.local_endpoint_group:
message = _("You must specify endpoint groups or peer CIDR(s)")
raise exceptions.CommandError(message)
obj = client.create_ipsec_site_connection(
{'ipsec_site_connection': attrs})['ipsec_site_connection']
columns, display_columns = column_util.get_columns(obj, _attr_map)
data = utils.get_dict_properties(obj, columns, formatters=_formatters)
return display_columns, data
def take_action(self, parsed_args):
client = self.app.client_manager.iam
table_columns = (
'Access Key',
'Description',
'User ID',
'Status',
'Created At',
)
attrs = {}
if parsed_args.user_id:
attrs['user_id'] = parsed_args.user_id
data = client.credentials(**attrs)
table = (table_columns, (utils.get_dict_properties(s, self.columns)
for s in data))
return table
def test_share_snapshot_instance_list_snapshot_id(self):
self.share_snapshot = (
manila_fakes.FakeShareSnapshot.create_one_snapshot())
self.share_snapshots_mock.get.return_value = self.share_snapshot
self.share_snapshot_instances_mock.list.return_value = ([
self.share_snapshot_instances[0]
])
values = (osc_lib_utils.get_dict_properties(s._info, COLUMNS)
for s in [self.share_snapshot_instances[0]])
arglist = ['--snapshot', self.share_snapshot.id]
verifylist = [('snapshot', self.share_snapshot.id)]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.assertEqual(COLUMNS, columns)
self.assertEqual(list(values), list(data))