def take_action_compute(self, client, parsed_args):
group = utils.find_resource(
client.security_groups,
parsed_args.group,
)
protocol = self._get_protocol(parsed_args)
if protocol == 'icmp':
from_port, to_port = -1, -1
else:
from_port, to_port = parsed_args.dst_port
src_ip = None
if parsed_args.src_group is not None:
parsed_args.src_group = utils.find_resource(
client.security_groups,
parsed_args.src_group,
).id
if parsed_args.src_ip is not None:
src_ip = parsed_args.src_ip
else:
src_ip = '0.0.0.0/0'
obj = client.security_group_rules.create(
group.id,
protocol,
from_port,
to_port,
src_ip,
parsed_args.src_group,
)
return _format_security_group_rule_show(obj._info)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
if parsed_args.long:
columns = ('ID', 'Name', 'Domain ID', 'Description', 'Enabled')
else:
columns = ('ID', 'Name')
kwargs = {}
domain_id = None
if parsed_args.domain:
domain_id = common.find_domain(identity_client,
parsed_args.domain).id
kwargs['domain'] = domain_id
if parsed_args.user:
if parsed_args.domain:
user_id = utils.find_resource(identity_client.users,
parsed_args.user,
domain_id=domain_id).id
else:
user_id = utils.find_resource(identity_client.users,
parsed_args.user).id
kwargs['user'] = user_id
data = identity_client.projects.list(**kwargs)
return (columns,
(utils.get_item_properties(
s, columns,
formatters={},
) for s in data))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
project_str = common._get_token_resource(identity_client, "project", parsed_args.project)
if parsed_args.domain:
domain = common.find_domain(identity_client, parsed_args.domain)
project = utils.find_resource(
identity_client.projects,
project_str,
domain_id=domain.id,
parents_as_list=parsed_args.parents,
subtree_as_list=parsed_args.children,
)
else:
project = utils.find_resource(
identity_client.projects,
project_str,
parents_as_list=parsed_args.parents,
subtree_as_list=parsed_args.children,
)
if project._info.get("parents"):
project._info["parents"] = [str(p["project"]["id"]) for p in project._info["parents"]]
if project._info.get("subtree"):
project._info["subtree"] = [str(p["project"]["id"]) for p in project._info["subtree"]]
project._info.pop("links")
return zip(*sorted(six.iteritems(project._info)))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
client_manager = self.app.client_manager
user = _determine_ec2_user(parsed_args, client_manager)
project_domain = None
if parsed_args.project_domain:
project_domain = common.find_domain(identity_client,
parsed_args.project_domain)
if parsed_args.project:
if project_domain is not None:
project = utils.find_resource(identity_client.projects,
parsed_args.project,
domain_id=project_domain.id).id
else:
project = utils.find_resource(
identity_client.projects,
parsed_args.project).id
else:
# Get the project from the current auth
project = self.app.client_manager.auth_ref.project_id
creds = identity_client.ec2.create(user, project)
info = {}
info.update(creds._info)
if 'tenant_id' in info:
info.update(
{'project_id': info.pop('tenant_id')}
)
return zip(*sorted(six.iteritems(info)))
def _determine_ec2_user(parsed_args, client_manager):
"""Determine a user several different ways.
Assumes parsed_args has user and user_domain arguments. Attempts to find
the user if domain scoping is provided, otherwise revert to a basic user
call. Lastly use the currently authenticated user.
"""
user_domain = None
if parsed_args.user_domain:
user_domain = common.find_domain(client_manager.identity,
parsed_args.user_domain)
if parsed_args.user:
if user_domain is not None:
user = utils.find_resource(client_manager.identity.users,
parsed_args.user,
domain_id=user_domain.id).id
else:
user = utils.find_resource(
client_manager.identity.users,
parsed_args.user).id
else:
# Get the user from the current auth
user = client_manager.auth_ref.user_id
return user
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
if parsed_args.project:
project = utils.find_resource(
identity_client.tenants,
parsed_args.project,
).id
else:
# Get the project from the current auth
project = self.app.client_manager.auth_ref.project_id
if parsed_args.user:
user = utils.find_resource(
identity_client.users,
parsed_args.user,
).id
else:
# Get the user from the current auth
user = self.app.client_manager.auth_ref.user_id
creds = identity_client.ec2.create(user, project)
info = {}
info.update(creds._info)
if 'tenant_id' in info:
info.update(
{'project_id': info.pop('tenant_id')}
)
return zip(*sorted(six.iteritems(info)))
def _image_ids(self):
if self.__kernel_id is not None and self.__ramdisk_id is not None:
return self.__kernel_id, self.__ramdisk_id
image_client = self.app.client_manager.image
kernel_id, ramdisk_id = None, None
try:
kernel_id = osc_utils.find_resource(
image_client.images, 'bm-deploy-kernel').id
except AttributeError:
self.log.exception("Please make sure there is only one image "
"named 'bm-deploy-kernel' in glance.")
except oscexc.CommandError:
# kernel_id=None will be returned and an error will be logged from
# self._check_boot_images
pass
try:
ramdisk_id = osc_utils.find_resource(
image_client.images, 'bm-deploy-ramdisk').id
except AttributeError:
self.log.exception("Please make sure there is only one image "
"named 'bm-deploy-ramdisk' in glance.")
except oscexc.CommandError:
# ramdisk_id=None will be returned and an error will be logged from
# self._check_boot_images
pass
self.log.debug("Using kernel ID: {0} and ramdisk ID: {1}".format(
kernel_id, ramdisk_id))
self.__kernel_id = kernel_id
self.__ramdisk_id = ramdisk_id
return kernel_id, ramdisk_id
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
project_str = common._get_token_resource(identity_client, 'project',
parsed_args.project)
if parsed_args.domain:
domain = common.find_domain(identity_client, parsed_args.domain)
project = utils.find_resource(
identity_client.projects,
project_str,
domain_id=domain.id,
parents_as_list=parsed_args.parents,
subtree_as_list=parsed_args.children)
else:
project = utils.find_resource(
identity_client.projects,
project_str,
parents_as_list=parsed_args.parents,
subtree_as_list=parsed_args.children)
if project._info.get('parents'):
project._info['parents'] = [str(p['project']['id'])
for p in project._info['parents']]
if project._info.get('subtree'):
project._info['subtree'] = [str(p['project']['id'])
for p in project._info['subtree']]
project._info.pop('links')
return zip(*sorted(six.iteritems(project._info)))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
domain = None
if parsed_args.domain:
domain = common.find_domain(identity_client, parsed_args.domain)
errors = 0
for user in parsed_args.users:
try:
if domain is not None:
user_obj = utils.find_resource(identity_client.users,
user,
domain_id=domain.id)
else:
user_obj = utils.find_resource(identity_client.users,
user)
identity_client.users.delete(user_obj.id)
except Exception as e:
errors += 1
LOG.error(_("Failed to delete user with "
"name or ID '%(user)s': %(e)s"),
{'user': user, 'e': e})
if errors > 0:
total = len(parsed_args.users)
msg = (_("%(errors)s of %(total)s users failed "
"to delete.") % {'errors': errors, 'total': total})
raise exceptions.CommandError(msg)
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
server = utils.find_resource(
compute_client.servers,
parsed_args.server,
)
# Set sane defaults as this API wants all mouths to be fed
if parsed_args.name is None:
backup_name = server.name
else:
backup_name = parsed_args.name
if parsed_args.type is None:
backup_type = ""
else:
backup_type = parsed_args.type
if parsed_args.rotate is None:
backup_rotation = 1
else:
backup_rotation = parsed_args.rotate
compute_client.servers.backup(
server.id,
backup_name,
backup_type,
backup_rotation,
)
image_client = self.app.client_manager.image
image = utils.find_resource(
image_client.images,
backup_name,
)
if parsed_args.wait:
if utils.wait_for_status(
image_client.images.get,
image.id,
callback=_show_progress,
):
sys.stdout.write('\n')
else:
msg = _('Error creating server backup: %s') % parsed_args.name
raise exceptions.CommandError(msg)
if self.app.client_manager._api_version['image'] == '1':
info = {}
info.update(image._info)
info['properties'] = utils.format_dict(info.get('properties', {}))
else:
# Get the right image module to format the output
image_module = importutils.import_module(
self.IMAGE_API_VERSIONS[
self.app.client_manager._api_version['image']
]
)
info = image_module._format_image(image)
return zip(*sorted(six.iteritems(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)
volume_type = utils.find_resource(volume_client.volume_types,
parsed_args.volume_type)
volume_client.qos_specs.associate(qos_spec.id, volume_type.id)
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
backup = utils.find_resource(volume_client.backups, parsed_args.backup)
destination_volume = utils.find_resource(volume_client.volumes,
parsed_args.volume)
backup = volume_client.restores.restore(backup.id,
destination_volume.id)
return zip(*sorted(six.iteritems(backup._info)))
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
backup = utils.find_resource(volume_client.backups,
parsed_args.backup)
destination_volume = utils.find_resource(volume_client.volumes,
parsed_args.volume)
return volume_client.restores.restore(backup.id,
destination_volume.id)
def take_action(self, parsed_args):
db_instances = self.app.client_manager.database.instances
db_flavor = self.app.client_manager.database.flavors
instance = osc_utils.find_resource(db_instances,
parsed_args.instance)
flavor = osc_utils.find_resource(db_flavor,
parsed_args.flavor_id)
db_instances.resize_instance(instance, flavor)
def take_action(self, parsed_args):
_check_size_arg(parsed_args)
identity_client = self.app.client_manager.identity
image_client = self.app.client_manager.image
volume_client = self.app.client_manager.volume
source_volume = None
if parsed_args.source:
source_volume = utils.find_resource(
volume_client.volumes,
parsed_args.source,
).id
project = None
if parsed_args.project:
project = utils.find_resource(
identity_client.tenants,
parsed_args.project,
).id
user = None
if parsed_args.user:
user = utils.find_resource(
identity_client.users,
parsed_args.user,
).id
image = None
if parsed_args.image:
image = utils.find_resource(
image_client.images,
parsed_args.image,
).id
snapshot = parsed_args.snapshot or parsed_args.snapshot_id
volume = volume_client.volumes.create(
parsed_args.size,
snapshot,
source_volume,
parsed_args.name,
parsed_args.description,
parsed_args.type,
user,
project,
parsed_args.availability_zone,
parsed_args.property,
image,
)
# Map 'metadata' column to 'properties'
volume._info.update(
{
'properties': utils.format_dict(volume._info.pop('metadata')),
'type': volume._info.pop('volume_type'),
},
)
return zip(*sorted(six.iteritems(volume._info)))
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
def _format_volume_id(volume_id):
"""Return a volume name if available
:param volume_id: a volume ID
:rtype: either the volume ID or name
"""
volume = volume_id
if volume_id in volume_cache.keys():
volume = volume_cache[volume_id].name
return volume
if parsed_args.long:
columns = ['ID', 'Name', 'Description', 'Status', 'Size',
'Availability Zone', 'Volume ID', 'Container']
column_headers = copy.deepcopy(columns)
column_headers[6] = 'Volume'
else:
columns = ['ID', 'Name', 'Description', 'Status', 'Size']
column_headers = columns
# Cache the volume list
volume_cache = {}
try:
for s in volume_client.volumes.list():
volume_cache[s.id] = s
except Exception:
# Just forget it if there's any trouble
pass
filter_volume_id = None
if parsed_args.volume:
filter_volume_id = utils.find_resource(volume_client.volumes,
parsed_args.volume).id
marker_backup_id = None
if parsed_args.marker:
marker_backup_id = utils.find_resource(volume_client.backups,
parsed_args.marker).id
search_opts = {
'name': parsed_args.name,
'status': parsed_args.status,
'volume_id': filter_volume_id,
'all_tenants': parsed_args.all_projects,
}
data = volume_client.backups.list(
search_opts=search_opts,
marker=marker_backup_id,
limit=parsed_args.limit,
)
return (column_headers,
(utils.get_item_properties(
s, columns,
formatters={'Volume ID': _format_volume_id},
) for s in data))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
auth_ref = self.app.client_manager.auth_ref
include_names = True if parsed_args.names else False
user = None
if parsed_args.user:
user = utils.find_resource(
identity_client.users,
parsed_args.user,
)
elif parsed_args.authuser:
if auth_ref:
user = utils.find_resource(
identity_client.users,
auth_ref.user_id
)
project = None
if parsed_args.project:
project = utils.find_resource(
identity_client.projects,
parsed_args.project,
)
elif parsed_args.authproject:
if auth_ref:
project = utils.find_resource(
identity_client.projects,
auth_ref.project_id
)
# If user or project is not specified, we would ideally list all
# relevant assignments in the system (to be compatible with v3).
# However, there is no easy way of doing that in v2.
if not user or not project:
msg = _("Project and User must be specified")
raise exceptions.CommandError(msg)
else:
data = identity_client.roles.roles_for_user(user.id, project.id)
columns = ('Role', 'User', 'Project')
for user_role in data:
if include_names:
setattr(user_role, 'role', user_role.name)
user_role.user = user.name
user_role.project = project.name
else:
setattr(user_role, 'role', user_role.id)
user_role.user = user.id
user_role.project = project.id
return (columns,
(utils.get_item_properties(
s, columns,
formatters={},
) for s in 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.volume_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):
def _show_progress(progress):
if progress:
self.app.stdout.write('\rProgress: %s' % progress)
self.app.stdout.flush()
compute_client = self.app.client_manager.compute
server = utils.find_resource(
compute_client.servers,
parsed_args.server,
)
if parsed_args.name:
image_name = parsed_args.name
else:
image_name = server.name
image_id = compute_client.servers.create_image(
server.id,
image_name,
)
image_client = self.app.client_manager.image
image = utils.find_resource(
image_client.images,
image_id,
)
if parsed_args.wait:
if utils.wait_for_status(
image_client.images.get,
image_id,
callback=_show_progress,
):
self.app.stdout.write('\n')
else:
LOG.error(_('Error creating server image: %s'),
parsed_args.server)
raise exceptions.CommandError
if self.app.client_manager._api_version['image'] == '1':
info = {}
info.update(image._info)
info['properties'] = utils.format_dict(info.get('properties', {}))
else:
# Get the right image module to format the output
image_module = importutils.import_module(
self.IMAGE_API_VERSIONS[
self.app.client_manager._api_version['image']
]
)
info = image_module._format_image(image)
return zip(*sorted(six.iteritems(info)))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
role = utils.find_resource(identity_client.roles, parsed_args.role)
project = utils.find_resource(
identity_client.tenants,
parsed_args.project,
)
user = utils.find_resource(identity_client.users, parsed_args.user)
identity_client.roles.remove_user_role(
user.id,
role.id,
project.id)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
domain = None
if parsed_args.domain:
domain = common.find_domain(identity_client, parsed_args.domain)
for project in parsed_args.projects:
if domain is not None:
project_obj = utils.find_resource(identity_client.projects, project, domain_id=domain.id)
else:
project_obj = utils.find_resource(identity_client.projects, project)
identity_client.projects.delete(project_obj.id)
def take_action(self, parsed_args):
self.log.warning(_('This command has been deprecated. '
'Please use "server add fixed ip" instead.'))
compute_client = self.app.client_manager.compute
network = utils.find_resource(
compute_client.networks, parsed_args.network)
server = utils.find_resource(
compute_client.servers, parsed_args.server)
server.add_fixed_ip(network.id)
def take_action(self, parsed_args):
database_client_manager = self.app.client_manager.database
db_clusters = database_client_manager.clusters
cluster = utils.find_resource(db_clusters,
parsed_args.cluster)
db_instances = database_client_manager.instances
instances = [
{'id': utils.find_resource(db_instances,
instance).id}
for instance in parsed_args.instances
]
db_clusters.shrink(cluster, instances)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
auth_ref = self.app.client_manager.auth_ref
# Project and user are required, if not included in command args
# default to the values used for authentication. For token-flow
# authentication they must be included on the command line.
if (not parsed_args.project and
self.app.client_manager.auth_ref.project_id):
parsed_args.project = auth_ref.project_id
if not parsed_args.project:
msg = _("Project must be specified")
raise exceptions.CommandError(msg)
if (not parsed_args.user and
self.app.client_manager.auth_ref.user_id):
parsed_args.user = auth_ref.user_id
if not parsed_args.user:
msg = _("User must be specified")
raise exceptions.CommandError(msg)
self.log.warning(_('Listing assignments using user role list is '
'deprecated as of the Newton release. Use role '
'assignment list --user <user-name> --project '
'<project-name> --names instead.'))
project = utils.find_resource(
identity_client.tenants,
parsed_args.project,
)
user = utils.find_resource(identity_client.users, parsed_args.user)
data = identity_client.roles.roles_for_user(user.id, project.id)
columns = (
'ID',
'Name',
'Project',
'User',
)
# Add the names to the output even though they will be constant
for role in data:
role.user = user.name
role.project = project.name
return (columns,
(utils.get_item_properties(
s, columns,
formatters={},
) for s in data))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
if parsed_args.project:
project_id = utils.find_resource(
identity_client.tenants,
parsed_args.project,
).id
else:
project_id = None
enabled = True
if parsed_args.disable:
enabled = False
if parsed_args.password_prompt:
parsed_args.password = utils.get_password(self.app.stdin)
if not parsed_args.password:
LOG.warning(_("No password was supplied, authentication will fail "
"when a user does not have a password."))
try:
user = identity_client.users.create(
parsed_args.name,
parsed_args.password,
parsed_args.email,
tenant_id=project_id,
enabled=enabled,
)
except ks_exc.Conflict:
if parsed_args.or_show:
user = utils.find_resource(
identity_client.users,
parsed_args.name,
)
LOG.info(_('Returning existing user %s'), user.name)
else:
raise
# NOTE(dtroyer): The users.create() method wants 'tenant_id' but
# the returned resource has 'tenantId'. Sigh.
# We're using project_id now inside OSC so there.
if 'tenantId' in user._info:
user._info.update(
{'project_id': user._info.pop('tenantId')}
)
info = {}
info.update(user._info)
return zip(*sorted(six.iteritems(info)))
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
volume_client = self.app.client_manager.volume
project_id = None
if parsed_args.project is not None:
identity_client = self.app.client_manager.identity
if parsed_args.domain is not None:
domain = identity_common.find_domain(identity_client,
parsed_args.domain)
project_id = utils.find_resource(identity_client.projects,
parsed_args.project,
domain_id=domain.id).id
else:
project_id = utils.find_resource(identity_client.projects,
parsed_args.project).id
compute_limits = None
volume_limits = None
if self.app.client_manager.is_compute_endpoint_enabled():
compute_limits = compute_client.limits.get(parsed_args.is_reserved,
tenant_id=project_id)
if self.app.client_manager.is_volume_endpoint_enabled(volume_client):
volume_limits = volume_client.limits.get()
data = []
if parsed_args.is_absolute:
if compute_limits:
data.append(compute_limits.absolute)
if volume_limits:
data.append(volume_limits.absolute)
columns = ["Name", "Value"]
return (columns, (utils.get_item_properties(s, columns)
for s in itertools.chain(*data)))
elif parsed_args.is_rate:
if compute_limits:
data.append(compute_limits.rate)
if volume_limits:
data.append(volume_limits.rate)
columns = ["Verb", "URI", "Value", "Remain", "Unit",
"Next Available"]
return (columns, (utils.get_item_properties(s, columns)
for s in itertools.chain(*data)))
else:
return {}, {}
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
domain = None
if parsed_args.domain:
domain = common.find_domain(identity_client, parsed_args.domain)
for user in parsed_args.users:
if domain is not None:
user_obj = utils.find_resource(identity_client.users,
user,
domain_id=domain.id)
else:
user_obj = utils.find_resource(identity_client.users,
user)
identity_client.users.delete(user_obj.id)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
role = utils.find_resource(identity_client.roles, parsed_args.role)
info = {}
info.update(role._info)
return zip(*sorted(six.iteritems(info)))
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
volume = utils.find_resource(volume_client.volumes, parsed_args.volume)
if parsed_args.size:
if volume.status != 'available':
LOG.error(_("Volume is in %s state, it must be available "
"before size can be extended"), volume.status)
return
if parsed_args.size <= volume.size:
LOG.error(_("New size must be greater than %s GB"),
volume.size)
return
volume_client.volumes.extend(volume.id, parsed_args.size)
if parsed_args.property:
volume_client.volumes.set_metadata(volume.id, parsed_args.property)
if parsed_args.image_property:
volume_client.volumes.set_image_metadata(
volume.id, parsed_args.image_property)
kwargs = {}
if parsed_args.name:
kwargs['display_name'] = parsed_args.name
if parsed_args.description:
kwargs['display_description'] = parsed_args.description
if kwargs:
volume_client.volumes.update(volume.id, **kwargs)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
user_str = common._get_token_resource(identity_client, 'user',
parsed_args.user)
if parsed_args.domain:
domain = common.find_domain(identity_client, parsed_args.domain)
user = utils.find_resource(identity_client.users,
user_str,
domain_id=domain.id)
else:
user = utils.find_resource(identity_client.users,
user_str)
user._info.pop('links')
return zip(*sorted(six.iteritems(user._info)))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
compute_client = self.app.client_manager.compute
dateformat = "%Y-%m-%d"
now = datetime.datetime.utcnow()
if parsed_args.start:
start = datetime.datetime.strptime(parsed_args.start, dateformat)
else:
start = now - datetime.timedelta(weeks=4)
if parsed_args.end:
end = datetime.datetime.strptime(parsed_args.end, dateformat)
else:
end = now + datetime.timedelta(days=1)
if parsed_args.project:
project = utils.find_resource(
identity_client.projects,
parsed_args.project,
).id
else:
# Get the project from the current auth
project = self.app.client_manager.auth_ref.project_id
usage = compute_client.usage.get(project, start, end)
if parsed_args.formatter == 'table':
sys.stdout.write(
_("Usage from %(start)s to %(end)s on "
"project %(project)s: \n") % {
"start": start.strftime(dateformat),
"end": end.strftime(dateformat),
"project": project,
})
info = {}
info['Servers'] = (len(usage.server_usages) if hasattr(
usage, "server_usages") else None)
info['RAM MB-Hours'] = (float(
"%.2f" % usage.total_memory_mb_usage) if hasattr(
usage, "total_memory_mb_usage") else None)
info['CPU Hours'] = (float("%.2f" % usage.total_vcpus_usage)
if hasattr(usage, "total_vcpus_usage") else None)
info['Disk GB-Hours'] = (float(
"%.2f" % usage.total_local_gb_usage) if hasattr(
usage, "total_local_gb_usage") else None)
return zip(*sorted(six.iteritems(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):
share_client = self.app.client_manager.share
share_snapshot = utils.find_resource(share_client.share_snapshots,
parsed_args.snapshot)
export_locations = (
share_client.share_snapshot_export_locations.list(share_snapshot))
export_locations = (cliutils.transform_export_locations_to_string_view(
export_locations))
data = share_snapshot._info
data['export_locations'] = export_locations
data.pop('links', None)
return self.dict2columns(data)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
# NOTE(stevemar): We want a list of role ids
roles = []
for role in parsed_args.role:
role_id = utils.find_resource(
identity_client.roles,
role,
).id
roles.append(role_id)
verifier_pin = identity_client.oauth1.request_tokens.authorize(
parsed_args.request_key, roles)
return zip(*sorted(six.iteritems(verifier_pin._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,
parsed_args.force,
parsed_args.name,
parsed_args.description
)
snapshot._info.update(
{'properties': utils.format_dict(snapshot._info.pop('metadata'))}
)
return zip(*sorted(six.iteritems(snapshot._info)))
def take_action(self, parsed_args):
bc_client = self.app.client_manager.baremetal_compute
group = utils.find_resource(bc_client.server_group,
parsed_args.server_group)
info = {}
info.update(group._info)
columns = (
'uuid',
'name',
'user_id',
'project_id',
'members',
'policies',
)
data = utils.get_dict_properties(info, columns, formatters=_formatters)
return columns, data
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
if volume_client.api_version < api_versions.APIVersion('3.14'):
msg = _(
"--os-volume-api-version 3.14 or greater is required to "
"support the 'volume group snapshot delete' command"
)
raise exceptions.CommandError(msg)
snapshot = utils.find_resource(
volume_client.group_snapshots,
parsed_args.snapshot,
)
volume_client.group_snapshots.delete(snapshot.id)
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
snapshot = utils.find_resource(volume_client.volume_snapshots,
parsed_args.snapshot)
if parsed_args.property:
volume_client.volume_snapshots.set_metadata(
snapshot.id, parsed_args.property)
kwargs = {}
if parsed_args.name:
kwargs['display_name'] = parsed_args.name
if parsed_args.description:
kwargs['display_description'] = parsed_args.description
snapshot.update(**kwargs)
def take_action(self, parsed_args):
LOG.debug("take_action({0})".format(parsed_args))
client = self.app.client_manager.application_catalog
client.sessions.deploy(parsed_args.id, parsed_args.session_id)
environment = utils.find_resource(client.environments, parsed_args.id)
data = client.environments.get(environment.id,
parsed_args.session_id).to_dict()
data['services'] = jsonutils.dumps(data['services'], indent=2)
if getattr(parsed_args, 'only_apps', False):
return (['services'], [data['services']])
else:
return self.dict2columns(data)
def take_action(self, parsed_args):
bc_client = self.app.client_manager.baremetal_compute
data = utils.find_resource(
bc_client.aggregate,
parsed_args.aggregate,
)
# 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(info.items()))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
domain_id = None
if parsed_args.domain:
domain_id = common.find_domain(identity_client,
parsed_args.domain).id
options = common.get_immutable_options(parsed_args)
role = utils.find_resource(identity_client.roles,
parsed_args.role,
domain_id=domain_id)
identity_client.roles.update(role.id, name=parsed_args.name,
description=parsed_args.description,
options=options)
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
volume = utils.find_resource(volume_client.volumes, parsed_args.volume)
# Map 'metadata' column to 'properties'
volume._info.update(
{
'properties': utils.format_dict(volume._info.pop('metadata')),
'type': volume._info.pop('volume_type'),
},
)
if 'os-vol-tenant-attr:tenant_id' in volume._info:
volume._info.update(
{'project_id': volume._info.pop(
'os-vol-tenant-attr:tenant_id')}
)
return zip(*sorted(six.iteritems(volume._info)))
def take_action(self, parsed_args):
image_client = self.app.client_manager.image
identity_client = self.app.client_manager.identity
project_id = common.find_project(identity_client, parsed_args.project,
parsed_args.project_domain).id
image_id = utils.find_resource(image_client.images,
parsed_args.image).id
image_member = image_client.image_members.create(
image_id,
project_id,
)
return zip(*sorted(six.iteritems(image_member)))
def _get_image(self, name):
try:
image = utils.find_resource(self.app.client_manager.image.images,
name)
except exceptions.CommandError as e:
# TODO(maufart): enhance error detection, when python-glanceclient
# starts provide it https://bugs.launchpad.net/glance/+bug/1480156
if 'More than one image exists' in e.args[0]:
raise exceptions.CommandError(
'Image "%s" already exists in glance more than once,'
' delete all copies except the first one.' % name)
else:
self.log.debug('Image "%s" does not exists, no problem.' %
name)
return None
return image
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
domain = utils.find_resource(identity_client.domains,
parsed_args.domain)
kwargs = {}
if parsed_args.name:
kwargs['name'] = parsed_args.name
if parsed_args.description:
kwargs['description'] = parsed_args.description
if parsed_args.enable:
kwargs['enabled'] = True
if parsed_args.disable:
kwargs['enabled'] = False
identity_client.domains.update(domain.id, **kwargs)
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(
{'properties': utils.format_dict(qos_spec._info.pop('specs'))})
return zip(*sorted(six.iteritems(qos_spec._info)))
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
consistency_group = parsed_args.consistency_group
if not parsed_args.consistency_group:
# If "--consistency-group" not specified, then consistency_group
# will be the same as the new consistency group snapshot name
consistency_group = parsed_args.snapshot_name
consistency_group_id = utils.find_resource(
volume_client.consistencygroups, consistency_group).id
consistency_group_snapshot = volume_client.cgsnapshots.create(
consistency_group_id,
name=parsed_args.snapshot_name,
description=parsed_args.description,
)
return zip(*sorted(consistency_group_snapshot._info.items()))
def _create_take_action(self, client, app, parsed_args):
if parsed_args.json:
blob = osc_utils.read_blob_file_contents(parsed_args.json)
try:
template = json.loads(blob)
except ValueError as e:
raise exceptions.CommandError('An error occurred when reading '
'template from file %s: %s' %
(parsed_args.json, e))
data = client.node_group_templates.create(**template).to_dict()
else:
if (not parsed_args.name or not parsed_args.plugin
or not parsed_args.plugin_version or not parsed_args.flavor
or not parsed_args.processes):
raise exceptions.CommandError(
'At least --name, --plugin, --plugin-version, --processes,'
' --flavor arguments should be specified or json template '
'should be provided with --json argument')
configs = None
if parsed_args.configs:
blob = osc_utils.read_blob_file_contents(parsed_args.configs)
try:
configs = json.loads(blob)
except ValueError as e:
raise exceptions.CommandError(
'An error occurred when reading '
'configs from file %s: %s' % (parsed_args.configs, e))
shares = None
if parsed_args.shares:
blob = osc_utils.read_blob_file_contents(parsed_args.shares)
try:
shares = json.loads(blob)
except ValueError as e:
raise exceptions.CommandError(
'An error occurred when reading '
'shares from file %s: %s' % (parsed_args.shares, e))
compute_client = app.client_manager.compute
flavor_id = osc_utils.find_resource(compute_client.flavors,
parsed_args.flavor).id
data = create_node_group_templates(client, app, parsed_args,
flavor_id, configs, shares)
return data
def take_action(self, parsed_args):
image_client = self.app.client_manager.image
image = utils.find_resource(
image_client.images,
parsed_args.image,
)
kwargs = {}
tagret = 0
propret = 0
if parsed_args.tags:
for k in parsed_args.tags:
try:
image_client.image_tags.delete(image.id, k)
except Exception:
LOG.error(_("tag unset failed, '%s' is a "
"nonexistent tag "), k)
tagret += 1
if parsed_args.properties:
for k in parsed_args.properties:
if k not in image:
LOG.error(_("property unset failed, '%s' is a "
"nonexistent property "), k)
propret += 1
image_client.images.update(
image.id,
parsed_args.properties,
**kwargs)
tagtotal = len(parsed_args.tags)
proptotal = len(parsed_args.properties)
if (tagret > 0 and propret > 0):
msg = (_("Failed to unset %(tagret)s of %(tagtotal)s tags,"
"Failed to unset %(propret)s of %(proptotal)s properties.")
% {'tagret': tagret, 'tagtotal': tagtotal,
'propret': propret, 'proptotal': proptotal})
raise exceptions.CommandError(msg)
elif tagret > 0:
msg = (_("Failed to unset %(tagret)s of %(tagtotal)s tags.")
% {'tagret': tagret, 'tagtotal': tagtotal})
raise exceptions.CommandError(msg)
elif propret > 0:
msg = (_("Failed to unset %(propret)s of %(proptotal)s"
" properties.")
% {'propret': propret, 'proptotal': proptotal})
raise exceptions.CommandError(msg)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
project_id = None
if parsed_args.project:
project_id = common.find_project(identity_client,
parsed_args.project,
parsed_args.project_domain).id
domain_id = None
if parsed_args.domain:
domain_id = common.find_domain(identity_client,
parsed_args.domain).id
enabled = True
if parsed_args.disable:
enabled = False
if parsed_args.password_prompt:
parsed_args.password = utils.get_password(self.app.stdin)
if not parsed_args.password:
LOG.warning(_("No password was supplied, authentication will fail "
"when a user does not have a password."))
options = _get_options_for_user(identity_client, parsed_args)
try:
user = identity_client.users.create(
name=parsed_args.name,
domain=domain_id,
default_project=project_id,
password=parsed_args.password,
email=parsed_args.email,
description=parsed_args.description,
enabled=enabled,
options=options,
)
except ks_exc.Conflict:
if parsed_args.or_show:
user = utils.find_resource(identity_client.users,
parsed_args.name,
domain_id=domain_id)
LOG.info(_('Returning existing user %s'), user.name)
else:
raise
user._info.pop('links')
return zip(*sorted(user._info.items()))
def take_action(self, parsed_args):
def _show_progress(progress):
if progress:
self.app.stdout.write('\rProgress: %s' % progress)
self.app.stdout.flush()
compute_client = self.app.client_manager.compute
server = utils.find_resource(
compute_client.servers,
parsed_args.server,
)
if parsed_args.name:
image_name = parsed_args.name
else:
image_name = server.name
image_id = compute_client.servers.create_image(
server.id,
image_name,
)
image_client = self.app.client_manager.image
image = image_client.find_image(image_id)
if parsed_args.wait:
if utils.wait_for_status(
image_client.get_image,
image_id,
callback=_show_progress,
):
self.app.stdout.write('\n')
else:
LOG.error(_('Error creating server image: %s'),
parsed_args.server)
raise exceptions.CommandError
if self.app.client_manager._api_version['image'] == '1':
info = {}
info.update(image._info)
info['properties'] = utils.format_dict(info.get('properties', {}))
else:
# Get the right image module to format the output
image_module = importutils.import_module(self.IMAGE_API_VERSIONS[
self.app.client_manager._api_version['image']])
info = image_module._format_image(image)
return zip(*sorted(info.items()))
def take_action(self, parsed_args):
share_client = self.app.client_manager.share
snapshot_obj = utils.find_resource(share_client.share_snapshots,
parsed_args.snapshot)
try:
snapshot_access = share_client.share_snapshots.allow(
snapshot=snapshot_obj,
access_type=parsed_args.access_type,
access_to=parsed_args.access_to)
return self.dict2columns(snapshot_access)
except Exception as e:
raise exceptions.CommandError(
"Failed to create access to share snapshot "
"'%s': %s" % (snapshot_obj, e))
def take_action(self, parsed_args):
LOG_DEP.warning(
_('This command has been deprecated. '
'Please use "volume snapshot create" instead.'))
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,
metadata=parsed_args.property,
)
snapshot._info.update(
{'properties': utils.format_dict(snapshot._info.pop('metadata'))})
return zip(*sorted(six.iteritems(snapshot._info)))
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
server = utils.find_resource(
compute_client.servers,
parsed_args.server,
)
if parsed_args.name:
server.update(name=parsed_args.name)
if parsed_args.property:
compute_client.servers.set_meta(
server,
parsed_args.property,
)
if parsed_args.state:
server.reset_state(state=parsed_args.state)
if parsed_args.root_password:
p1 = getpass.getpass(_('New password: '******'Retype new password: '))
if p1 == p2:
server.change_password(p1)
else:
msg = _("Passwords do not match, password unchanged")
raise exceptions.CommandError(msg)
if parsed_args.description:
if server.api_version < api_versions.APIVersion("2.19"):
msg = _("Description is not supported for "
"--os-compute-api-version less than 2.19")
raise exceptions.CommandError(msg)
server.update(description=parsed_args.description)
if parsed_args.tag:
if server.api_version < api_versions.APIVersion("2.26"):
msg = _("Modifying tags is not supported for "
"--os-compute-api-version less than 2.26")
raise exceptions.CommandError(msg)
sdk.load(self.app.client_manager.sdk_connection)
client = self.app.client_manager.sdk_connection.compute
server = client.get_server(server.id)
for tag in parsed_args.tag:
server.add_tag(client, tag)
def take_action(self, parsed_args):
share_client = self.app.client_manager.share
share_snapshot = utils.find_resource(share_client.share_snapshots,
parsed_args.snapshot)
export_locations = (
share_client.share_snapshot_export_locations.list(share_snapshot))
export_locations = cliutils.convert_dict_list_to_string(
export_locations, ignored_keys=['links'])
data = share_snapshot._info
data['export_locations'] = export_locations
data.pop('links', None)
return self.dict2columns(data)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
client = self.app.client_manager.data_processing
image_client = self.app.client_manager.image
image_id = osc_utils.find_resource(image_client.images,
parsed_args.image).id
data = client.images.update_image(image_id,
user_name=parsed_args.username,
desc=parsed_args.description).image
data['tags'] = osc_utils.format_list(data['tags'])
data = utils.prepare_data(data, IMAGE_FIELDS)
return self.dict2columns(data)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
try:
role = identity_client.roles.create(parsed_args.role_name)
except ks_exc.Conflict:
if parsed_args.or_show:
role = utils.find_resource(
identity_client.roles,
parsed_args.role_name,
)
LOG.info(_('Returning existing role %s'), role.name)
else:
raise
info = {}
info.update(role._info)
return zip(*sorted(six.iteritems(info)))
def _find_volumes(parsed_args_volumes, volume_client):
result = 0
uuid = ''
for volume in parsed_args_volumes:
try:
volume_id = utils.find_resource(volume_client.volumes, volume).id
uuid += volume_id + ','
except Exception as e:
result += 1
LOG.error(
_("Failed to find volume with "
"name or ID '%(volume)s':%(e)s") % {
'volume': volume,
'e': e
})
return result, uuid
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
hypervisor = utils.find_resource(compute_client.hypervisors,
parsed_args.hypervisor)._info.copy()
aggregates = compute_client.aggregates.list()
hypervisor["aggregates"] = list()
if aggregates:
# Hypervisors in nova cells are prefixed by "<cell>@"
if "@" in hypervisor['service']['host']:
cell, service_host = hypervisor['service']['host'].split(
'@', 1)
else:
cell = None
service_host = hypervisor['service']['host']
if cell:
# The host aggregates are also prefixed by "<cell>@"
member_of = [
aggregate.name for aggregate in aggregates if
cell in aggregate.name and service_host in aggregate.hosts
]
else:
member_of = [
aggregate.name for aggregate in aggregates
if service_host in aggregate.hosts
]
hypervisor["aggregates"] = member_of
uptime = compute_client.hypervisors.uptime(hypervisor['id'])._info
# Extract data from uptime value
# format: 0 up 0, 0 users, load average: 0, 0, 0
# example: 17:37:14 up 2:33, 3 users, load average: 0.33, 0.36, 0.34
m = re.match("(.+)\sup\s+(.+),\s+(.+)\susers,\s+load average:\s(.+)",
uptime['uptime'])
if m:
hypervisor["host_time"] = m.group(1)
hypervisor["uptime"] = m.group(2)
hypervisor["users"] = m.group(3)
hypervisor["load_average"] = m.group(4)
hypervisor["service_id"] = hypervisor["service"]["id"]
hypervisor["service_host"] = hypervisor["service"]["host"]
del hypervisor["service"]
return zip(*sorted(six.iteritems(hypervisor)))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
# NOTE(stevemar): Find the two users, project and roles that
# are necessary for making a trust usable, the API dictates that
# trustee, project and role are optional, but that makes the trust
# pointless, and trusts are immutable, so let's enforce it at the
# client level.
trustor_id = common.find_user(identity_client, parsed_args.trustor,
parsed_args.trustor_domain).id
trustee_id = common.find_user(identity_client, parsed_args.trustee,
parsed_args.trustee_domain).id
project_id = common.find_project(identity_client, parsed_args.project,
parsed_args.project_domain).id
role_names = []
for role in parsed_args.role:
role_name = utils.find_resource(
identity_client.roles,
role,
).name
role_names.append(role_name)
expires_at = None
if parsed_args.expiration:
expires_at = datetime.datetime.strptime(parsed_args.expiration,
'%Y-%m-%dT%H:%M:%S')
trust = identity_client.trusts.create(
trustee_id,
trustor_id,
impersonation=parsed_args.impersonate,
project=project_id,
role_names=role_names,
expires_at=expires_at,
)
trust._info.pop('roles_links', None)
trust._info.pop('links', None)
# Format roles into something sensible
roles = trust._info.pop('roles')
msg = ' '.join(r['name'] for r in roles)
trust._info['roles'] = msg
return zip(*sorted(six.iteritems(trust._info)))
