def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
rows = []
columns = [
'ID',
'Stack Name',
'Stack Status',
'Creation Time',
'Updated Time'
]
heat_client = self.app.client_manager.orchestration
for stack in parsed_args.stack:
try:
data = heat_client.stacks.get(stack_id=stack)
except heat_exc.HTTPNotFound:
raise exc.CommandError('Stack not found: %s' % stack)
status = getattr(data, 'stack_status').lower()
if status == 'update_in_progress':
data = _stack_action(
stack,
parsed_args,
heat_client,
heat_client.actions.cancel_update
)
rows += [utils.get_dict_properties(data.to_dict(), columns)]
else:
err = _("Stack %(id)s with status \'%(status)s\' "
"not in cancelable state") % {
'id': stack, 'status': status}
raise exc.CommandError(err)
return (columns, rows)
def take_action(self, parsed_args):
iam_client = self.app.client_manager.sss
identity_client = self.app.client_manager.identity
columns = (
'contract_id',
'iam_role_id',
'iam_role_name',
'description',
'resources'
)
column_headers = (
'Contract ID',
'ID',
'Name',
'Description'
'Resources'
)
if parsed_args.resources == "":
resources_list = []
else:
resources_list = json.loads("[" + parsed_args.resources + "]")
data = iam_client.iam_role_create(contract_id=parsed_args.contract_id,
iam_role_name=parsed_args.name,
description=parsed_args.description,
resources=resources_list)
return (column_headers, utils.get_dict_properties(data, columns))
def _show_config(heat_client, config_id, config_only):
try:
sc = heat_client.software_configs.get(config_id=config_id)
except heat_exc.HTTPNotFound:
raise exc.CommandError(_('Configuration not found: %s') % config_id)
columns = None
rows = None
if config_only:
print(sc.config)
else:
columns = (
'id',
'name',
'group',
'config',
'inputs',
'outputs',
'options',
'creation_time',
)
rows = utils.get_dict_properties(sc.to_dict(), columns)
return columns, rows
def take_action(self, parsed_args):
if parsed_args.long:
columns = (
'Name',
'Bytes',
'Hash',
'Content Type',
'Last Modified',
)
else:
columns = ('Name', )
kwargs = {}
if parsed_args.prefix:
kwargs['prefix'] = parsed_args.prefix
if parsed_args.delimiter:
kwargs['delimiter'] = parsed_args.delimiter
if parsed_args.marker:
kwargs['marker'] = parsed_args.marker
if parsed_args.end_marker:
kwargs['end_marker'] = parsed_args.end_marker
if parsed_args.limit:
kwargs['limit'] = parsed_args.limit
if parsed_args.all:
kwargs['full_listing'] = True
data = self.app.client_manager.object_store.object_list(
container=parsed_args.container, **kwargs)
return (columns, (utils.get_dict_properties(
s,
columns,
formatters={},
) for s in data))
def take_action(self, parsed_args):
iam_client = self.app.client_manager.sss
identity_client = self.app.client_manager.identity
columns = ('contract_id', 'iam_group_id', 'iam_group_name',
'description')
column_headers = ('Contract ID', 'ID', 'Name', 'Description')
data = iam_client.iam_group_create(contract_id=parsed_args.contract_id,
iam_group_name=parsed_args.name,
description=parsed_args.description)
return (column_headers, utils.get_dict_properties(data, columns))
def _list_snapshot(self, heat_client, parsed_args):
fields = {'stack_id': parsed_args.stack}
try:
snapshots = heat_client.stacks.snapshot_list(**fields)
except heat_exc.HTTPNotFound:
raise exc.CommandError(
_('Stack not found: %s') % parsed_args.stack)
columns = ['id', 'name', 'status', 'status_reason', 'creation_time']
return (columns, (utils.get_dict_properties(s, columns)
for s in snapshots['snapshots']))
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
heat_client = self.app.client_manager.orchestration
result = heat_client.build_info.build_info()
formatters = {
'api': heat_utils.json_formatter,
'engine': heat_utils.json_formatter,
}
columns = sorted(list(six.iterkeys(result)))
return columns, utils.get_dict_properties(result, columns,
formatters=formatters)
def _stacks_action(parsed_args, heat_client, action, action_name=None):
rows = []
columns = [
'ID',
'Stack Name',
'Stack Status',
'Creation Time',
# 'Updated Time'
]
for stack in parsed_args.stack:
data = _stack_action(stack, parsed_args, heat_client, action,
action_name)
rows += [utils.get_dict_properties(data.to_dict(), columns)]
return (columns, rows)
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
heat_client = self.app.client_manager.orchestration
try:
data = heat_client.stacks.snapshot(parsed_args.stack,
parsed_args.name)
except heat_exc.HTTPNotFound:
raise exc.CommandError(
_('Stack not found: %s') % parsed_args.stack)
columns = [
'ID', 'name', 'status', 'status_reason', 'data', 'creation_time'
]
return (columns, utils.get_dict_properties(data, columns))
def take_action(self, parsed_args):
bare_client = self.app.client_manager.bare
columns = (
'Type',
'URL',
'User ID',
'Password',
)
server_obj = utils.find_resource(bare_client.servers,
parsed_args.server)
data = bare_client.servers.get_management_console(
server_obj.id)['console']
return columns, utils.get_dict_properties(data, columns)
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
client = self.app.client_manager.orchestration
try:
outputs = client.stacks.output_list(parsed_args.stack)['outputs']
except heat_exc.HTTPNotFound:
msg = _('Stack not found: %s') % parsed_args.stack
raise exc.CommandError(msg)
columns = ['output_key', 'description']
return (columns, (utils.get_dict_properties(s, columns)
for s in outputs))
def take_action(self, parsed_args):
results = []
for container in parsed_args.containers:
data = self.app.client_manager.object_store.container_create(
container=container,
)
results.append(data)
columns = ("account", "container", "x-trans-id")
return (columns,
(utils.get_dict_properties(
s, columns,
formatters={},
) for s in results))
def take_action(self, parsed_args):
results = []
for obj in parsed_args.objects:
data = self.app.client_manager.object_store.object_create(
container=parsed_args.container,
object=obj,
)
results.append(data)
columns = ("object", "container", "etag")
return (columns, (utils.get_dict_properties(
s,
columns,
formatters={},
) for s in results))
def take_action(self, parsed_args):
# This is ugly because if auth hasn't happened yet we need
# to trigger it here.
sc = self.app.client_manager.session.auth.get_auth_ref(
self.app.client_manager.session, ).service_catalog
data = sc.get_data()
columns = ('Name', 'Type', 'Endpoints')
return (columns, (utils.get_dict_properties(
s,
columns,
formatters={
'Endpoints': _format_endpoints,
},
) for s in data))
def take_action(self, parsed_args):
security_order_client = self.app.eclsdk.conn.security_order
columns = [
'hostname',
'availability_zone',
'internal_use',
'menu',
'plan',
'zone_name',
]
devices = security_order_client.wafs(parsed_args.locale)
return (columns,
(utils.get_dict_properties(
d, columns,
) for d in devices.devices))
def take_action(self, parsed_args):
iam_client = self.app.client_manager.sss
identity_client = self.app.client_manager.identity
columns = (
'iam_group_id',
'iam_group_name',
'user_id',
)
column_headers = (
'Group ID',
'Group Name',
'User ID',
)
data = iam_client.iam_group_attach_user(iam_group_id=parsed_args.group,
iam_user_id=parsed_args.user)
return (column_headers, utils.get_dict_properties(data, columns))
def take_action(self, parsed_args):
iam_client = self.app.client_manager.sss
identity_client = self.app.client_manager.identity
columns = (
'iam_role_name',
'iam_role_id',
'description',
'resources'
)
column_headers = (
'Name',
'ID',
'Description',
'Resources'
)
data = iam_client.iam_role_show(parsed_args.role)
return (column_headers, utils.get_dict_properties(data, columns))
def take_action(self, parsed_args):
iam_client = self.app.client_manager.sss
identity_client = self.app.client_manager.identity
columns = (
'iam_role_name',
'iam_role_id',
'description',
)
column_headers = (
'Name',
'ID',
'Description',
)
data = iam_client.iam_role_list(
contract_id=parsed_args.contract_id)['iam_roles']
return (column_headers, (utils.get_dict_properties(s, columns)
for s in data))
def take_action(self, parsed_args):
iam_client = self.app.client_manager.sss
identity_client = self.app.client_manager.identity
columns = (
'iam_group_name',
'iam_group_id',
'description',
'users',
)
column_headers = (
'Group Name',
'ID',
'Description',
'Users',
)
data = iam_client.iam_user_list(parsed_args.group)
return (column_headers, utils.get_dict_properties(data, columns))
def take_action(self, parsed_args):
volume_client = self.app.client_manager.volume
qos_specs_list = volume_client.qos_specs.list()
for qos in qos_specs_list:
qos_associations = volume_client.qos_specs.get_associations(qos)
if qos_associations:
associations = [
association.name for association in qos_associations
]
qos._info.update({'associations': associations})
columns = ('ID', 'Name', 'Consumer', 'Associations', 'Specs')
return (columns, (utils.get_dict_properties(
s._info,
columns,
formatters={
'Specs': utils.format_dict,
'Associations': utils.format_list
},
) for s in qos_specs_list))
def take_action(self, parsed_args):
if parsed_args.long:
columns = ('Zone Name', 'Zone Status', 'Zone Resource',
'Host Name', 'Service Name', 'Service Status')
else:
columns = ('Zone Name', 'Zone Status')
# Show everything by default.
show_all = (not parsed_args.compute and not parsed_args.volume
and not parsed_args.network)
result = []
if parsed_args.compute or show_all:
result += self._get_compute_availability_zones(parsed_args)
if parsed_args.volume or show_all:
result += self._get_volume_availability_zones(parsed_args)
if parsed_args.network or show_all:
result += self._get_network_availability_zones(parsed_args)
return (columns, (utils.get_dict_properties(s, columns)
for s in result))
def take_action(self, parsed_args):
image_client = self.app.client_manager.image
kwargs = {}
if parsed_args.public:
kwargs['public'] = True
if parsed_args.private:
kwargs['private'] = True
if parsed_args.shared:
kwargs['shared'] = True
if parsed_args.limit:
kwargs['limit'] = parsed_args.limit
if parsed_args.marker:
kwargs['marker'] = utils.find_resource(image_client.images,
parsed_args.marker).id
if parsed_args.long:
columns = (
'ID',
'Name',
'Disk Format',
'Container Format',
'Size',
'Status',
'visibility',
'protected',
'owner',
'tags',
)
column_headers = (
'ID',
'Name',
'Disk Format',
'Container Format',
'Size',
'Status',
'Visibility',
'Protected',
'Project',
'Tags',
)
else:
columns = ("ID", "Name", "Status")
column_headers = columns
# List of image data received
data = image_client.api.image_list(**kwargs)
if parsed_args.property:
# NOTE(dtroyer): coerce to a list to subscript it in py3
attr, value = list(parsed_args.property.items())[0]
api_utils.simple_filter(
data,
attr=attr,
value=value,
property_field='properties',
)
data = utils.sort_items(data, parsed_args.sort)
return (column_headers, (utils.get_dict_properties(
s,
columns,
formatters={
'tags': utils.format_list,
},
) for s in data))
