def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
identity_client = self.app.client_manager.identity
user = utils.find_resource(
identity_client.users, parsed_args.user)
kwargs = {}
if parsed_args.name:
kwargs['name'] = parsed_args.name
if parsed_args.email:
kwargs['email'] = parsed_args.email
if parsed_args.password:
kwargs['password'] = parsed_args.password
if parsed_args.description:
kwargs['description'] = parsed_args.description
if parsed_args.project:
project_id = utils.find_resource(
identity_client.projects, parsed_args.project).id
kwargs['projectId'] = project_id
if parsed_args.domain:
domain_id = utils.find_resource(
identity_client.domains, parsed_args.domain).id
kwargs['domainId'] = domain_id
if 'enabled' in parsed_args:
kwargs['enabled'] = parsed_args.enabled
if not len(kwargs):
sys.stderr.write("User not updated, no arguments present")
return
identity_client.users.update(user.id, **kwargs)
return
def take_action(self, parsed_args):
self.log.debug("take_action: (%s)", 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_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):
self.log.debug('take_action(%s)' % parsed_args)
identity_client = self.app.client_manager.identity
if parsed_args.project:
project_id = utils.find_resource(
identity_client.projects, parsed_args.project).id
else:
project_id = None
if parsed_args.domain:
domain_id = utils.find_resource(
identity_client.domains, parsed_args.domain).id
else:
domain_id = None
user = identity_client.users.create(
parsed_args.name,
domain_id,
project_id,
parsed_args.password,
parsed_args.email,
parsed_args.description,
parsed_args.enabled
)
info = {}
info.update(user._info)
return zip(*sorted(info.iteritems()))
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
bm_client = self.app.client_manager.rdomanager_oscplugin.baremetal()
image_client = self.app.client_manager.image
kernel_id = utils.find_resource(
image_client.images, 'bm-deploy-kernel').id
ramdisk_id = utils.find_resource(
image_client.images, 'bm-deploy-ramdisk').id
self.log.debug("Using kernel ID: {0} and ramdisk ID: {1}".format(
kernel_id, ramdisk_id))
for node in bm_client.node.list():
self.log.debug("Configuring boot for Node {0}".format(
node.uuid))
bm_client.node.update(node.uuid, [
{
'op': 'add',
'path': '/properties/capabilities',
'value': 'boot_option:local',
},
{
'op': 'add',
'path': '/driver_info/deploy_ramdisk',
'value': ramdisk_id,
},
{
'op': 'add',
'path': '/driver_info/deploy_kernel',
'value': kernel_id,
},
])
def get_data(self, parsed_args):
self.log.debug("get_data(%s)" % parsed_args)
identity_client = self.app.client_manager.identity
role = utils.find_resource(identity_client.roles, parsed_args.role)
tenant = utils.find_resource(identity_client.tenants, parsed_args.tenant)
user = utils.find_resource(identity_client.users, parsed_args.user)
identity_client.roles.remove_user_role(user.id, role.id, tenant.id)
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
server = utils.find_resource(compute_client.servers, parsed_args.server)
security_group = utils.find_resource(compute_client.security_groups, parsed_args.group)
server.remove_security_group(security_group)
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:
self.log.exception("Error finding 'bm-deploy-kernel' in "
"glance.")
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:
self.log.exception("Error finding 'bm-deploy-ramdisk' in "
"glance.")
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):
self.log.debug('take_action(%s)' % parsed_args)
identity_client = self.app.client_manager.identity
if parsed_args.project:
project_id = utils.find_resource(
identity_client.projects,
parsed_args.project,
).id
else:
project_id = None
if parsed_args.domain:
domain_id = utils.find_resource(
identity_client.domains, parsed_args.domain).id
else:
domain_id = None
enabled = True
if parsed_args.disable:
enabled = False
user = identity_client.users.create(
parsed_args.name,
domain=domain_id,
default_project=project_id,
password=parsed_args.password,
email=parsed_args.email,
description=parsed_args.description,
enabled=enabled
)
info = {}
info.update(user._info)
return zip(*sorted(six.iteritems(info)))
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
columns = ('ID', 'Name', 'Tenant ID', 'User ID')
identity_client = self.app.client_manager.identity
# user-only roles are not supported in KSL so we are
# required to have a user and tenant; default to the
# values used for authentication if not specified
if not parsed_args.tenant:
parsed_args.tenant = identity_client.auth_tenant_id
if not parsed_args.user:
parsed_args.user = identity_client.auth_user_id
tenant = utils.find_resource(identity_client.tenants,
parsed_args.tenant)
user = utils.find_resource(identity_client.users, parsed_args.user)
data = identity_client.roles.roles_for_user(user.id, tenant.id)
# Add the names to the output even though they will be constant
for role in data:
role.user_id = user.name
role.tenant_id = tenant.name
return (columns,
(utils.get_item_properties(
s, columns,
formatters={},
) for s in data))
def get_data(self, parsed_args):
self.log.debug('get_data(%s)' % parsed_args)
nova_client = self.app.client_manager.compute
server = utils.find_resource(nova_client.servers, parsed_args.server)
info = {}
info.update(server._info)
# Convert the flavor blob to a name
flavor_info = info.get('flavor', {})
flavor_id = flavor_info.get('id', '')
flavor = utils.find_resource(nova_client.flavors, flavor_id)
info['flavor'] = flavor.name
# Convert the image blob to a name
image_info = info.get('image', {})
image_id = image_info.get('id', '')
image = utils.find_resource(nova_client.images, image_id)
info['image'] = image.name
# Format addresses in a useful way
info['addresses'] = _format_servers_list_networks(server)
# Remove a couple of values that are long and not too useful
info.pop('links', None)
columns = sorted(info.keys())
values = [info[c] for c in columns]
return (columns, values)
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', {})
image_id = image_info.get('id', '')
image = utils.find_resource(compute_client.images, image_id)
info['image'] = "%s (%s)" % (image.name, image_id)
# Convert the flavor blob to a name
flavor_info = info.get('flavor', {})
flavor_id = flavor_info.get('id', '')
flavor = utils.find_resource(compute_client.flavors, flavor_id)
info['flavor'] = "%s (%s)" % (flavor.name, flavor_id)
# NOTE(dtroyer): novaclient splits these into separate entries...
# Format addresses in a useful way
info['addresses'] = _format_servers_list_networks(server)
# Remove values that are long and not too useful
info.pop('links', None)
return info
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % 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 = identity_client.auth_tenant_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 = identity_client.auth_user_id
creds = identity_client.ec2.create(user, project)
info = {}
info.update(creds._info)
return zip(*sorted(six.iteritems(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):
self.log.debug('take_action(%s)' % parsed_args)
identity_client = self.app.client_manager.identity
user = utils.find_resource(identity_client.users, parsed_args.user)
if parsed_args.password:
identity_client.users.update_password(
user.id,
parsed_args.password,
)
if parsed_args.project:
project = utils.find_resource(
identity_client.tenants,
parsed_args.project,
)
identity_client.users.update_tenant(
user.id,
project.id,
)
kwargs = {}
if parsed_args.name:
kwargs['name'] = parsed_args.name
if parsed_args.email:
kwargs['email'] = parsed_args.email
if parsed_args.enable:
kwargs['enabled'] = True
if parsed_args.disable:
kwargs['enabled'] = False
if len(kwargs):
identity_client.users.update(user.id, **kwargs)
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
compute_client = self.app.client_manager.compute
server = utils.find_resource(
compute_client.servers,
parsed_args.server,
)
if parsed_args.flavor:
flavor = utils.find_resource(
compute_client.flavors,
parsed_args.flavor,
)
server.resize(flavor)
if parsed_args.wait:
if utils.wait_for_status(
compute_client.servers.get,
server.id,
success_status=['active', 'verify_resize'],
callback=_show_progress,
):
sys.stdout.write('Complete\n')
else:
sys.stdout.write('\nError resizing server')
raise SystemExit
elif parsed_args.verify:
server.confirm_resize()
elif parsed_args.revert:
server.revert_resize()
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
if parsed_args.domain:
domain = common.find_domain(identity_client, parsed_args.domain)
project = utils.find_resource(
identity_client.projects,
parsed_args.project,
domain_id=domain.id,
parents_as_list=parsed_args.parents,
subtree_as_list=parsed_args.children)
else:
project = utils.find_resource(
identity_client.projects,
parsed_args.project,
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
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 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):
self.log.debug("take_action(%s)" % 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):
self.log.debug("take_action(%s)" % 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:
if self.app.client_manager.auth_ref:
parsed_args.project = auth_ref.project_id
else:
msg = "Project must be specified"
raise exceptions.CommandError(msg)
if not parsed_args.user:
if self.app.client_manager.auth_ref:
parsed_args.user = auth_ref.user_id
else:
msg = "User must be specified"
raise exceptions.CommandError(msg)
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):
self.log.debug('take_action(%s)', 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):
self.log.debug("take_action: (%s)", 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):
compute_client = self.app.client_manager.compute
volume_client = self.app.client_manager.volume
server = utils.find_resource(compute_client.servers, parsed_args.server)
volume = utils.find_resource(volume_client.volumes, parsed_args.volume)
compute_client.volumes.delete_server_volume(server.id, volume.id)
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)
return
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
compute_client = self.app.client_manager.compute
utils.find_resource(
compute_client.servers,
parsed_args.server,
).pause()
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):
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):
self.log.debug("take_action(%s)" % 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)
role = identity_client.roles.add_user_role(user.id, role.id, project.id)
info = {}
info.update(role._info)
return zip(*sorted(six.iteritems(info)))
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
identity_client = self.app.client_manager.identity
user_id = utils.find_resource(identity_client.users,
parsed_args.user).id
kwargs = {}
if user_id:
kwargs['user'] = user_id
if parsed_args.type:
kwargs['type'] = parsed_args.type
if parsed_args.data:
kwargs['data'] = parsed_args.data
if parsed_args.project:
project = utils.find_resource(identity_client.projects,
parsed_args.project).id
kwargs['project'] = project
if not kwargs:
sys.stdout.write("Credential not updated, no arguments present")
return
identity_client.credentials.update(parsed_args.credential, **kwargs)
return
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
compute_client = self.app.client_manager.compute
server = utils.find_resource(
compute_client.servers,
parsed_args.server,
)
if parsed_args.property:
compute_client.servers.delete_meta(
server,
parsed_args.property,
)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
auth_ref = self.app.client_manager.auth_ref
# No user or project specified, list all roles in the system
if not parsed_args.user and not parsed_args.project:
columns = ('ID', 'Name')
data = identity_client.roles.list()
elif parsed_args.user and parsed_args.project:
user = utils.find_resource(
identity_client.users,
parsed_args.user,
)
project = utils.find_resource(
identity_client.projects,
parsed_args.project,
)
data = identity_client.roles.roles_for_user(user.id, project.id)
elif parsed_args.user:
user = utils.find_resource(
identity_client.users,
parsed_args.user,
)
if self.app.client_manager.auth_ref:
project = utils.find_resource(
identity_client.projects,
auth_ref.project_id
)
else:
msg = _("Project must be specified")
raise exceptions.CommandError(msg)
data = identity_client.roles.roles_for_user(user.id, project.id)
elif parsed_args.project:
project = utils.find_resource(
identity_client.projects,
parsed_args.project,
)
if self.app.client_manager.auth_ref:
user = utils.find_resource(
identity_client.users,
auth_ref.user_id
)
else:
msg = _("User must be specified")
raise exceptions.CommandError(msg)
data = identity_client.roles.roles_for_user(user.id, project.id)
if parsed_args.user or parsed_args.project:
columns = ('ID', 'Name', 'Project', 'User')
for user_role in data:
user_role.user = user.name
user_role.project = project.name
return (columns,
(utils.get_item_properties(
s, columns,
formatters={},
) for s in data))
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
backup = volume_client.backups.create(
volume_id,
parsed_args.container,
parsed_args.name,
parsed_args.description
)
backup._info.pop('links')
return zip(*sorted(six.iteritems(backup._info)))
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
compute_client = self.app.client_manager.compute
server = utils.find_resource(
compute_client.servers,
parsed_args.server,
)
# NOTE(dtroyer): get_console_output() appears to shortchange the
# output by one line
data = server.get_console_output(length=parsed_args.lines + 1)
sys.stdout.write(data)
return
def take_action(self, parsed_args):
self.log.debug("take_action: (%s)", parsed_args)
volume_client = self.app.client_manager.volume
volume_id = utils.find_resource(
volume_client.volumes, parsed_args.volume).id
backup = volume_client.backups.create(
volume_id,
container=parsed_args.container,
name=parsed_args.name,
description=parsed_args.description
)
backup._info.pop("links", None)
return zip(*sorted(six.iteritems(backup._info)))
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
identity_client = self.app.client_manager.identity
if parsed_args.password_prompt:
parsed_args.password = utils.get_password(self.app.stdin)
if (not parsed_args.name and not parsed_args.name
and not parsed_args.password and not parsed_args.email
and not parsed_args.project and not parsed_args.description
and not parsed_args.enable and not parsed_args.disable):
return
user = utils.find_resource(
identity_client.users,
parsed_args.user,
)
kwargs = {}
if parsed_args.name:
kwargs['name'] = parsed_args.name
if parsed_args.email:
kwargs['email'] = parsed_args.email
if parsed_args.password:
kwargs['password'] = parsed_args.password
if parsed_args.description:
kwargs['description'] = parsed_args.description
if parsed_args.project:
project_id = utils.find_resource(identity_client.projects,
parsed_args.project).id
kwargs['default_project'] = project_id
kwargs['enabled'] = user.enabled
if parsed_args.enable:
kwargs['enabled'] = True
if parsed_args.disable:
kwargs['enabled'] = False
identity_client.users.update(user.id, **kwargs)
return
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
volume_client = self.app.client_manager.volume
volume = utils.find_resource(volume_client.volumes, parsed_args.volume)
if parsed_args.property:
volume_client.volumes.delete_metadata(
volume.id,
parsed_args.property,
)
else:
self.app.log.error("No changes requested\n")
return
def _get_project(self, parsed_args):
if parsed_args.project is not None:
identity_client = self.app.client_manager.identity
project = utils.find_resource(
identity_client.projects,
parsed_args.project,
).id
elif self.app.client_manager.auth_ref:
# Get the project from the current auth
project = self.app.client_manager.auth_ref.project_id
else:
project = None
return project
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
image_client = self.app.client_manager.image
image = utils.find_resource(
image_client.images,
parsed_args.image,
)
info = {}
info.update(image._info)
info['properties'] = utils.format_dict(info.get('properties', {}))
return zip(*sorted(six.iteritems(info)))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
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
identity_client.ec2.delete(user, parsed_args.access_key)
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.delete_metadata(
snapshot.id,
parsed_args.property,
)
else:
self.app.log.error("No changes requested\n")
return
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
if not parsed_args.name:
return
role = utils.find_resource(
identity_client.roles,
parsed_args.role,
)
identity_client.roles.update(role.id, name=parsed_args.name)
return
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
identity_client = self.app.client_manager.identity
endpoint = utils.find_resource(identity_client.endpoints,
parsed_args.endpoint)
service = common.find_service(identity_client, endpoint.service_id)
info = {}
info.update(endpoint._info)
info['service_name'] = service.name
info['service_type'] = service.type
return zip(*sorted(six.iteritems(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_client.image_members.delete(image_id, project_id)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
endpoint = utils.find_resource(identity_client.endpoints,
parsed_args.endpoint)
service = common.find_service(identity_client, endpoint.service_id)
info = {}
endpoint._info.pop('links')
info.update(endpoint._info)
info['service_name'] = get_service_name(service)
info['service_type'] = service.type
return zip(*sorted(six.iteritems(info)))
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
identity_client = self.app.client_manager.identity
project = utils.find_resource(identity_client.projects,
parsed_args.project)
kwargs = {}
if parsed_args.name:
kwargs['name'] = parsed_args.name
if parsed_args.domain:
domain = utils.find_resource(identity_client.domains,
parsed_args.domain).id
kwargs['domain'] = domain
if parsed_args.description:
kwargs['description'] = parsed_args.description
if 'enabled' in parsed_args:
kwargs['enabled'] = parsed_args.enabled
if kwargs == {}:
sys.stdout.write("Project not updated, no arguments present")
return
project.update(**kwargs)
return
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.property:
volume_client.volumes.delete_metadata(volume.id,
parsed_args.property)
if parsed_args.image_property:
volume_client.volumes.delete_image_metadata(
volume.id, parsed_args.image_property)
if (not parsed_args.image_property and not parsed_args.property):
self.app.log.error("No changes requested\n")
def take_action(self, parsed_args):
self.log.debug("take_action: (%s)", 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 take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
volume_client = self.app.client_manager.volume
volume_type = utils.find_resource(
volume_client.volume_types,
parsed_args.volume_type,
)
if parsed_args.property:
volume_type.unset_keys(parsed_args.property)
else:
self.app.log.error("No changes requested\n")
return
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', '')
image = utils.find_resource(compute_client.images, image_id)
info['image'] = "%s (%s)" % (image.name, image_id)
# Convert the flavor blob to a name
flavor_info = info.get('flavor', {})
flavor_id = flavor_info.get('id', '')
flavor = utils.find_resource(compute_client.flavors, flavor_id)
info['flavor'] = "%s (%s)" % (flavor.name, 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'))})
# Remove values that are long and not too useful
info.pop('links', None)
return info
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
trust = utils.find_resource(identity_client.trusts, parsed_args.trust)
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)))
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 = compute_client.limits.get(parsed_args.is_reserved,
tenant_id=project_id)
volume_limits = volume_client.limits.get()
if parsed_args.is_absolute:
compute_limits = compute_limits.absolute
volume_limits = volume_limits.absolute
columns = ["Name", "Value"]
return (columns, (utils.get_item_properties(s, columns)
for s in itertools.chain(compute_limits, volume_limits)))
elif parsed_args.is_rate:
compute_limits = compute_limits.rate
volume_limits = volume_limits.rate
columns = ["Verb", "URI", "Value", "Remain", "Unit",
"Next Available"]
return (columns, (utils.get_item_properties(s, columns)
for s in itertools.chain(compute_limits, volume_limits)))
else:
return ({}, {})
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
identity_client = self.app.client_manager.identity
volume_type = utils.find_resource(
volume_client.volume_types, parsed_args.volume_type)
result = 0
kwargs = {}
if parsed_args.name:
kwargs['name'] = parsed_args.name
if parsed_args.description:
kwargs['description'] = parsed_args.description
if kwargs:
try:
volume_client.volume_types.update(
volume_type.id,
**kwargs
)
except Exception as e:
self.app.log.error(_("Failed to update volume type name or"
" description: %s") % str(e))
result += 1
if parsed_args.property:
try:
volume_type.set_keys(parsed_args.property)
except Exception as e:
self.app.log.error(_("Failed to set volume type"
" property: %s") % str(e))
result += 1
if parsed_args.project:
project_info = None
try:
project_info = identity_common.find_project(
identity_client,
parsed_args.project,
parsed_args.project_domain)
volume_client.volume_type_access.add_project_access(
volume_type.id, project_info.id)
except Exception as e:
self.app.log.error(_("Failed to set volume type access to"
" project: %s") % str(e))
result += 1
if result > 0:
raise exceptions.CommandError(_("Command Failed: One or more of"
" the operations failed"))
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
compute_client = self.app.client_manager.compute
server = utils.find_resource(
compute_client.servers,
parsed_args.server,
)
# Build the command
cmd = "ssh"
# Look for address type
if parsed_args.address_type:
address_type = parsed_args.address_type
if address_type not in server.addresses:
raise SystemExit("ERROR: No %s IP address found" % address_type)
# Set up desired address family
ip_address_family = [4, 6]
if parsed_args.ipv4:
ip_address_family = [4]
cmd += " -4"
if parsed_args.ipv6:
ip_address_family = [6]
cmd += " -6"
# Grab the first matching IP address
ip_address = None
for addr in server.addresses[address_type]:
if int(addr['version']) in ip_address_family:
ip_address = addr['addr']
if not ip_address:
raise SystemExit("ERROR: No IP address found")
if parsed_args.port:
cmd += " -p %d" % parsed_args.port
if parsed_args.identity:
cmd += " -i %s" % parsed_args.identity
if parsed_args.option:
cmd += " -o %s" % parsed_args.option
if parsed_args.login:
login = parsed_args.login
else:
login = self.app.client_manager._username
if parsed_args.verbose:
cmd += " -v"
cmd += " %s@%s"
self.log.debug("ssh command: %s", (cmd % (login, ip_address)))
os.system(cmd % (login, ip_address))
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
identity_client = self.app.client_manager.identity
if parsed_args.domain:
domain = utils.find_resource(
identity_client.domains,
parsed_args.domain,
).id
else:
domain = None
if parsed_args.group:
group = utils.find_resource(
identity_client.groups,
parsed_args.group,
).id
else:
group = None
# List users
if parsed_args.long:
columns = ('ID', 'Name', 'Project Id', 'Domain Id',
'Description', 'Email', 'Enabled')
else:
columns = ('ID', 'Name')
data = identity_client.users.list(
domain=domain,
group=group,
)
return (
columns,
(utils.get_item_properties(
s, columns,
formatters={},
) for s in data)
)
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
identity_client = self.app.client_manager.identity
if (not parsed_args.name and not parsed_args.description
and not parsed_args.domain and not parsed_args.enable
and not parsed_args.property and not parsed_args.disable):
return
project = utils.find_resource(
identity_client.projects,
parsed_args.project,
)
kwargs = project._info
if parsed_args.name:
kwargs['name'] = parsed_args.name
if parsed_args.domain:
kwargs['domain'] = utils.find_resource(
identity_client.domains,
parsed_args.domain,
).id
if parsed_args.description:
kwargs['description'] = parsed_args.description
if parsed_args.enable:
kwargs['enabled'] = True
if parsed_args.disable:
kwargs['enabled'] = False
if parsed_args.property:
kwargs.update(parsed_args.property)
if 'id' in kwargs:
del kwargs['id']
if 'domain_id' in kwargs:
# Hack around borken Identity API arg names
kwargs.update({'domain': kwargs.pop('domain_id')})
identity_client.projects.update(project.id, **kwargs)
return
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
identity_client = self.app.client_manager.identity
endpoint = utils.find_resource(identity_client.endpoints,
parsed_args.endpoint)
service = utils.find_resource(identity_client.services,
parsed_args.service)
if (not parsed_args.interface and not parsed_args.url
and not parsed_args.service and not parsed_args.region):
sys.stdout.write("Endpoint not updated, no arguments present")
return
identity_client.endpoints.update(
endpoint.id,
service.id,
parsed_args.url,
parsed_args.interface,
parsed_args.region,
parsed_args.enabled
)
return
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
if not parsed_args.name:
sys.stderr.write("Incorrect set of arguments "
"provided. See openstack --help for more "
"details\n")
return
role = utils.find_resource(
identity_client.roles,
parsed_args.role,
)
identity_client.roles.update(role.id, name=parsed_args.name)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
compute_client = self.app.client_manager.compute
aggregate = utils.find_resource(
compute_client.aggregates,
parsed_args.aggregate,
)
data = compute_client.aggregates.add_host(aggregate, parsed_args.host)
info = {}
info.update(data._info)
return zip(*sorted(six.iteritems(info)))
