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
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 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 _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):
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):
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):
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):
identity_client = self.app.client_manager.identity
if parsed_args.domain:
domain = common.find_domain(identity_client, parsed_args.domain)
user = utils.find_resource(identity_client.users,
parsed_args.user,
domain_id=domain.id)
else:
user = utils.find_resource(identity_client.users, parsed_args.user)
user._info.pop('links')
return zip(*sorted(six.iteritems(user._info)))
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):
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
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.enable
and not parsed_args.disable):
return
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
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 _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):
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):
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):
identity_client = self.app.client_manager.identity
enabled = True
if parsed_args.disable:
enabled = False
kwargs = {}
if parsed_args.property:
kwargs = parsed_args.property.copy()
try:
project = identity_client.tenants.create(
parsed_args.name,
description=parsed_args.description,
enabled=enabled,
**kwargs)
except ks_exc.Conflict as e:
if parsed_args.or_show:
project = utils.find_resource(
identity_client.tenants,
parsed_args.name,
)
self.log.info('Returning existing project %s', project.name)
else:
raise e
# TODO(stevemar): Remove the line below when we support multitenancy
project._info.pop('parent_id', None)
return zip(*sorted(six.iteritems(project._info)))
def take_action(self, parsed_args):
bare_client = self.app.client_manager.bare
server_obj = utils.find_resource(bare_client.servers,
parsed_args.server)
bare_client.servers.stop(server_obj.id)
return {}, {}
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
server = utils.find_resource(compute_client.servers,
parsed_args.server)
server.remove_fixed_ip(parsed_args.ip_address)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
domain = utils.find_resource(identity_client.domains,
parsed_args.domain)
domain._info.pop('links')
return zip(*sorted(six.iteritems(domain._info)))
def take_action(self, parsed_args):
bare_client = self.app.client_manager.bare
search_opts = {}
self.log.debug('search options: %s', search_opts)
columns = (
'Flavor ID',
'Flavor Name',
'Message',
'Setting',
'Updated',
'Status',
)
server_obj = utils.find_resource(bare_client.servers, parsed_args.server)
data = bare_client.uefis.get(server_obj.id)
return columns, utils.get_item_properties(
data,
columns,
mixed_case_fields=[],
formatters={
'Setting': bare_utils._format_dicts_list_generic
}
)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
if (not parsed_args.name and not parsed_args.description
and not parsed_args.enable and not parsed_args.property
and not parsed_args.disable):
return
project = utils.find_resource(
identity_client.tenants,
parsed_args.project,
)
kwargs = project._info
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
if parsed_args.property:
kwargs.update(parsed_args.property)
if 'id' in kwargs:
del kwargs['id']
if 'name' in kwargs:
# Hack around broken Identity API arg names
kwargs['tenant_name'] = kwargs['name']
del kwargs['name']
identity_client.tenants.update(project.id, **kwargs)
return
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,
)
volume_type.unset_keys(parsed_args.property)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
credential = utils.find_resource(identity_client.credentials,
parsed_args.credential)
credential._info.pop('links')
return zip(*sorted(six.iteritems(credential._info)))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
user_id = utils.find_resource(identity_client.users,
parsed_args.user).id
if parsed_args.project:
project = utils.find_resource(identity_client.projects,
parsed_args.project).id
else:
project = None
credential = identity_client.credentials.create(user=user_id,
type=parsed_args.type,
blob=parsed_args.data,
project=project)
credential._info.pop('links')
return zip(*sorted(six.iteritems(credential._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':
self.app.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:
self.app.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)
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)
if not kwargs and not parsed_args.property and not parsed_args.size:
self.app.log.error("No changes requested\n")
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):
identity_client = self.app.client_manager.identity
consumer = utils.find_resource(identity_client.oauth1.consumers,
parsed_args.consumer)
consumer._info.pop('links', None)
return zip(*sorted(six.iteritems(consumer._info)))
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
endpoint = utils.find_resource(identity_client.endpoints,
parsed_args.endpoint)
if (not parsed_args.interface and not parsed_args.url
and not parsed_args.service and not parsed_args.region
and not parsed_args.enabled and not parsed_args.disabled):
sys.stdout.write("Endpoint not updated, no arguments present")
return
service_id = None
if parsed_args.service:
service = common.find_service(identity_client, parsed_args.service)
service_id = service.id
enabled = None
if parsed_args.enabled:
enabled = True
if parsed_args.disabled:
enabled = False
identity_client.endpoints.update(endpoint.id,
service=service_id,
url=parsed_args.url,
interface=parsed_args.interface,
region=parsed_args.region,
enabled=enabled)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
user_id = utils.find_resource(identity_client.users,
parsed_args.user).id
if parsed_args.project:
project = utils.find_resource(identity_client.projects,
parsed_args.project).id
else:
project = None
identity_client.credentials.update(parsed_args.credential,
user=user_id,
type=parsed_args.type,
blob=parsed_args.data,
project=project)
def take_action(self, parsed_args):
identity_client = self.app.client_manager.identity
policy = utils.find_resource(identity_client.policies,
parsed_args.policy)
policy._info.pop('links')
policy._info.update({'rules': policy._info.pop('blob')})
return zip(*sorted(six.iteritems(policy._info)))
