def _format_image(image):
"""Format an image to make it more consistent with OSC operations. """
info = {}
properties = {}
# the only fields we're not including is "links", "tags" and the properties
fields_to_show = ['status', 'name', 'container_format', 'created_at',
'size', 'disk_format', 'updated_at', 'visibility',
'min_disk', 'protected', 'id', 'file', 'checksum',
'owner', 'virtual_size', 'min_ram', 'schema']
# split out the usual key and the properties which are top-level
for key in six.iterkeys(image):
if key in fields_to_show:
info[key] = image.get(key)
elif key == 'tags':
continue # handle this later
else:
properties[key] = image.get(key)
# format the tags if they are there
info['tags'] = utils.format_list(image.get('tags'))
# add properties back into the dictionary as a top-level key
if properties:
info['properties'] = utils.format_dict(properties)
return info
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
volume_type = utils.find_resource(volume_client.volume_types,
parsed_args.volume_type)
properties = utils.format_dict(volume_type._info.pop('extra_specs'))
volume_type._info.update({'properties': properties})
return zip(*sorted(six.iteritems(volume_type._info)))
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
snapshot = utils.find_resource(
volume_client.volume_snapshots, parsed_args.snapshot)
snapshot._info.update(
{'properties': utils.format_dict(snapshot._info.pop('metadata'))}
)
return zip(*sorted(six.iteritems(snapshot._info)))
def take_action(self, parsed_args):
data = self.app.client_manager.object_store.container_show(
container=parsed_args.container,
)
if 'properties' in data:
data['properties'] = utils.format_dict(data.pop('properties'))
return zip(*sorted(six.iteritems(data)))
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
resource_flavor = utils.find_resource(compute_client.flavors,
parsed_args.flavor)
flavor = resource_flavor._info.copy()
flavor.pop("links", None)
flavor['properties'] = utils.format_dict(resource_flavor.get_keys())
return zip(*sorted(six.iteritems(flavor)))
def take_action(self, parsed_args):
client = self.app.eclsdk.conn.provider_connectivity
body = {
'tenant_connection_request_id':
parsed_args.tenant_connection_request_id,
'device_type': parsed_args.device_type,
'device_id': parsed_args.device_id,
}
if parsed_args.name:
body['name'] = parsed_args.name
if parsed_args.description:
body['description'] = parsed_args.description
if parsed_args.tags:
tags = {}
for tag in parsed_args.tags:
tags.update(tag)
body['tags'] = tags
if parsed_args.device_interface_id:
body['device_interface_id'] = parsed_args.device_interface_id
attachment_opts = dict()
if parsed_args.segmentation_type:
attachment_opts['segmentation_type'] = \
parsed_args.segmentation_type
if parsed_args.segmentation_id:
attachment_opts['segmentation_id'] = parsed_args.segmentation_id
if parsed_args.fixed_ip:
attachment_opts['fixed_ip'] = parsed_args.fixed_ip
if len(attachment_opts.keys()) > 0:
body['attachment_opts'] = attachment_opts
data = client.create_tenant_connection(**body)._body
if 'tags' in data:
data['tags'] = utils.format_dict(data.pop('tags'))
if 'tags_other' in data:
data['tags_other'] = utils.format_dict(data.pop('tags_other'))
return zip(*sorted(six.iteritems(data)))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
volume_client = self.app.client_manager.volume
image_client = self.app.client_manager.image
source_volume = None
if parsed_args.source:
source_volume = utils.find_resource(volume_client.volumes,
parsed_args.source).id
image = None
if parsed_args.image:
image = utils.find_resource(image_client.images,
parsed_args.image).id
snapshot = None
if parsed_args.snapshot:
snapshot = utils.find_resource(volume_client.snapshots,
parsed_args.snapshot).id
project = None
if parsed_args.project:
project = utils.find_resource(identity_client.projects,
parsed_args.project).id
user = None
if parsed_args.user:
user = utils.find_resource(identity_client.users,
parsed_args.user).id
volume = volume_client.volumes.create(
size=parsed_args.size,
snapshot_id=snapshot,
name=parsed_args.name,
description=parsed_args.description,
volume_type=parsed_args.type,
user_id=user,
project_id=project,
availability_zone=parsed_args.availability_zone,
metadata=parsed_args.property,
imageRef=image,
source_volid=source_volume)
# Remove key links from being displayed
volume._info.update({
'properties':
utils.format_dict(volume._info.pop('metadata')),
'type':
volume._info.pop('volume_type')
})
volume._info.pop("links", None)
return zip(*sorted(six.iteritems(volume._info)))
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
volume_id = utils.find_resource(
volume_client.volumes, parsed_args.volume).id
snapshot = volume_client.volume_snapshots.create(
volume_id,
force=parsed_args.force,
name=parsed_args.name,
description=parsed_args.description
)
snapshot._info.update(
{'properties': utils.format_dict(snapshot._info.pop('metadata'))}
)
return zip(*sorted(six.iteritems(snapshot._info)))
def _prep_server_detail(compute_client, server):
"""Prepare the detailed server dict for printing
:param compute_client: a compute client instance
:param server: a Server resource
:rtype: a dict of server details
"""
info = server._info.copy()
# Call .get() to retrieve all of the server information
# as findall(name=blah) and REST /details are not the same
# and do not return flavor and image information.
server = compute_client.servers.get(info['id'])
info.update(server._info)
# Convert the image blob to a name
image_info = info.get('image', {})
if image_info:
image_id = image_info.get('id', '')
try:
image = utils.find_resource(compute_client.images, image_id)
info['image'] = "%s (%s)" % (image.name, image_id)
except Exception:
info['image'] = image_id
# Convert the flavor blob to a name
flavor_info = info.get('flavor', {})
flavor_id = flavor_info.get('id', '')
try:
flavor = utils.find_resource(compute_client.flavors, flavor_id)
info['flavor'] = "%s (%s)" % (flavor.name, flavor_id)
except Exception:
info['flavor'] = flavor_id
# NOTE(dtroyer): novaclient splits these into separate entries...
# Format addresses in a useful way
info['addresses'] = _format_servers_list_networks(server.networks)
# Map 'metadata' field to 'properties'
info.update({'properties': utils.format_dict(info.pop('metadata'))})
# Migrate tenant_id to project_id naming
if 'tenant_id' in info:
info['project_id'] = info.pop('tenant_id')
# Remove values that are long and not too useful
info.pop('links', None)
return info
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
qos_spec = utils.find_resource(volume_client.qos_specs,
parsed_args.qos_spec)
qos_associations = volume_client.qos_specs.get_associations(qos_spec)
if qos_associations:
associations = [
association.name for association in qos_associations
]
qos_spec._info.update(
{'associations': utils.format_list(associations)})
qos_spec._info.update({'specs': utils.format_dict(qos_spec.specs)})
return zip(*sorted(six.iteritems(qos_spec._info)))
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
volume = utils.find_resource(volume_client.volumes, parsed_args.volume)
# Special mapping for columns to make the output easier to read:
# 'metadata' --> 'properties'
# 'volume_type' --> 'type'
volume._info.update(
{
'properties': utils.format_dict(volume._info.pop('metadata')),
'type': volume._info.pop('volume_type'),
}, )
# Remove key links from being displayed
volume._info.pop("links", None)
return zip(*sorted(six.iteritems(volume._info)))
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
kwargs = {}
if parsed_args.public:
kwargs['is_public'] = True
if parsed_args.private:
kwargs['is_public'] = False
volume_type = volume_client.volume_types.create(
parsed_args.name, description=parsed_args.description, **kwargs)
volume_type._info.pop('extra_specs')
if parsed_args.property:
result = volume_type.set_keys(parsed_args.property)
volume_type._info.update({'properties': utils.format_dict(result)})
return zip(*sorted(six.iteritems(volume_type._info)))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
info = {}
try:
project = utils.find_resource(
identity_client.tenants,
parsed_args.project,
)
info.update(project._info)
except ks_exc.Forbidden as e:
auth_ref = self.app.client_manager.auth_ref
if (parsed_args.project == auth_ref.project_id
or parsed_args.project == auth_ref.project_name):
# Ask for currently auth'ed project so return it
info = {
'id': auth_ref.project_id,
'name': auth_ref.project_name,
# True because we don't get this far if it is disabled
'enabled': True,
}
else:
raise e
# TODO(stevemar): Remove the line below when we support multitenancy
info.pop('parent_id', None)
# NOTE(stevemar): Property handling isn't really supported in Keystone
# and needs a lot of extra handling. Let's reserve the properties that
# the API has and handle the extra top level properties.
reserved = ('name', 'id', 'enabled', 'description')
properties = {}
for k, v in info.items():
if k not in reserved:
# If a key is not in `reserved` it's a property, pop it
info.pop(k)
# If a property has been "unset" it's `None`, so don't show it
if v is not None:
properties[k] = v
info['properties'] = utils.format_dict(properties)
return zip(*sorted(six.iteritems(info)))
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
info = {}
info.update(
utils.find_resource(
compute_client.security_groups,
parsed_args.group,
)._info)
rules = []
for r in info['rules']:
formatted_rule = _xform_and_trim_security_group_rule(r)
rules.append(utils.format_dict(formatted_rule))
# Format rules into a list of strings
info.update({'rules': utils.format_list(rules, separator='\n')})
# Map 'tenant_id' column to 'project_id'
info.update({'project_id': info.pop('tenant_id')})
return zip(*sorted(six.iteritems(info)))
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
data = utils.find_resource(
compute_client.aggregates,
parsed_args.aggregate,
)
# Remove availability_zone from metadata because Nova doesn't
if 'availability_zone' in data.metadata:
data.metadata.pop('availability_zone')
# Special mapping for columns to make the output easier to read:
# 'metadata' --> 'properties'
data._info.update(
{
'properties': utils.format_dict(data._info.pop('metadata')),
},
)
info = {}
info.update(data._info)
return zip(*sorted(six.iteritems(info)))