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 _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):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
policy = senlin_client.get_cluster_policy(parsed_args.policy,
parsed_args.cluster)
columns = list(six.iterkeys(policy))
return columns, utils.get_dict_properties(policy.to_dict(), columns)
def _stack_action(parsed_args, heat_client, action, good_status, bad_status):
rows = []
for stack in parsed_args.stack:
try:
action(stack)
except heat_exc.HTTPNotFound:
msg = _('Stack not found: %s') % stack
raise exc.CommandError(msg)
if parsed_args.wait:
if not utils.wait_for_status(heat_client.stacks.get, stack,
status_field='stack_status',
success_status=good_status,
error_status=bad_status):
err = _("Error waiting for status from stack %s") % stack
raise exc.CommandError(err)
data = heat_client.stacks.get(stack)
columns = [
'ID',
'Stack Name',
'Stack Status',
'Creation Time',
'Updated Time'
]
rows += [utils.get_dict_properties(data.to_dict(), columns)]
return (columns, rows)
def _show_profile(senlin_client, profile_id):
try:
data = senlin_client.get_profile(profile_id)
except sdk_exc.ResourceNotFound:
raise exc.CommandError('Profile not found: %s' % profile_id)
else:
formatters = {}
formatters['metadata'] = senlin_utils.json_formatter
formatters['spec'] = senlin_utils.nested_dict_formatter(
['type', 'version', 'properties'],
['property', 'value'])
columns = [
'created_at',
'domain',
'id',
'metadata',
'name',
'project',
'spec',
'type',
'updated_at',
'user'
]
return columns, utils.get_dict_properties(data.to_dict(), columns,
formatters=formatters)
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
client = self.app.client_manager.network
if parsed_args.dhcp:
list_method = getattr(client, 'list_networks_on_dhcp_agent')
resources = 'networks_on_dhcp_agent'
report_filter = {'dhcp_agent': parsed_args.dhcp}
data = list_method(**report_filter)[resources]
else:
list_method = getattr(client, "list_networks")
report_filter = {}
if parsed_args.external:
report_filter = {'router:external': True}
data = list_method(**report_filter)['networks']
columns = len(data) > 0 and sorted(data[0].keys()) or []
if parsed_args.columns:
list_columns = parsed_args.columns
else:
list_columns = ['id', 'name', 'subnets']
if not parsed_args.long and not parsed_args.dhcp:
columns = [x for x in list_columns if x in columns]
formatters = {'subnets': utils.format_list}
return (columns, (utils.get_dict_properties(s,
columns,
formatters=formatters)
for s in data))
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
policy = senlin_client.get_cluster_policy(parsed_args.policy,
parsed_args.cluster)
columns = list(six.iterkeys(policy))
return columns, utils.get_dict_properties(policy.to_dict(), columns)
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
client = self.app.client_manager.network
if parsed_args.dhcp:
list_method = getattr(client, 'list_networks_on_dhcp_agent')
resources = 'networks_on_dhcp_agent'
report_filter = {'dhcp_agent': parsed_args.dhcp}
data = list_method(**report_filter)[resources]
else:
list_method = getattr(client, "list_networks")
report_filter = {}
if parsed_args.external:
report_filter = {'router:external': True}
data = list_method(**report_filter)['networks']
columns = len(data) > 0 and sorted(data[0].keys()) or []
if parsed_args.columns:
list_columns = parsed_args.columns
else:
list_columns = ['id', 'name', 'subnets']
if not parsed_args.long and not parsed_args.dhcp:
columns = [x for x in list_columns if x in columns]
formatters = {'subnets': utils.format_list}
return (columns,
(utils.get_dict_properties(s, columns, formatters=formatters)
for s in data))
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):
self.log.debug("take_action(%s)", parsed_args)
search_client = self.app.client_manager.search
columns = (
"Resource Type",
"Type",
"Name",
"Options"
)
params = {
"type": parsed_args.type,
"limit_terms": parsed_args.limit_terms,
"all_projects": parsed_args.all_projects
}
data = search_client.facets.list(**params)
result = []
for resource_type, values in six.iteritems(data):
for s in values:
options = []
for o in s.get('options', []):
options.append(
str(o['key']) + '(' + str(o['doc_count']) + ')')
s["options"] = ', '.join(options)
s["resource_type"] = resource_type
result.append(utils.get_dict_properties(s, columns))
return (columns, result)
def take_action(self, parsed_args):
if parsed_args.long:
columns = ('Zone Name', 'Zone Status',
'Host Name', 'Service Name', 'Service Status')
else:
columns = ('Zone Name', 'Zone Status')
compute_client = self.app.client_manager.compute
try:
data = compute_client.availability_zones.list()
except nova_exceptions.Forbidden as e: # policy doesn't allow
try:
data = compute_client.availability_zones.list(detailed=False)
except Exception:
raise e
# Argh, the availability zones are not iterable...
result = []
for zone in data:
result += _xform_availability_zone(zone, parsed_args.long)
return (columns,
(utils.get_dict_properties(
s, columns
) for s in result))
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
if parsed_args.long:
columns = ('Zone Name', 'Zone Status', 'Host Name', 'Service Name',
'Service Status')
else:
columns = ('Zone Name', 'Zone Status')
compute_client = self.app.client_manager.compute
try:
data = compute_client.availability_zones.list()
except nova_exceptions.Forbidden as e: # policy doesn't allow
try:
data = compute_client.availability_zones.list(detailed=False)
except Exception:
raise e
# Argh, the availability zones are not iterable...
result = []
for zone in data:
result += _xform_availability_zone(zone, parsed_args.long)
return (columns, (utils.get_dict_properties(s, columns)
for s in result))
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
if parsed_args.long:
columns = ('Name', 'Bytes', 'Count')
else:
columns = ('Name',)
kwargs = {}
if parsed_args.prefix:
kwargs['prefix'] = parsed_args.prefix
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 = lib_container.list_containers(
self.app.restapi,
self.app.client_manager.object_store.endpoint,
**kwargs
)
return (columns,
(utils.get_dict_properties(
s, columns,
formatters={},
) for s in data))
def take_action(self, parsed_args):
if parsed_args.long:
columns = ('Name', 'Bytes', 'Count')
else:
columns = ('Name', )
kwargs = {}
if parsed_args.prefix:
kwargs['prefix'] = parsed_args.prefix
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.container_list(**kwargs)
return (columns, (utils.get_dict_properties(
s,
columns,
formatters={},
) for s in data))
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 _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_compute(self, client, parsed_args):
obj = utils.find_resource(
client.floating_ips,
parsed_args.floating_ip,
)
columns = _get_columns(obj._info)
data = utils.get_dict_properties(obj._info, columns)
return (columns, data)
def take_action_compute(self, client, parsed_args):
obj = utils.find_resource(
client.floating_ips,
parsed_args.floating_ip,
)
columns = _get_columns(obj._info)
data = utils.get_dict_properties(obj._info, columns)
return (columns, data)
def take_action_compute(self, client, parsed_args):
network = utils.find_resource(
client.networks,
parsed_args.network,
)
columns = sorted(network._info.keys())
data = utils.get_dict_properties(network._info, columns)
return (columns, data)
def take_action_compute(self, client, parsed_args):
network = utils.find_resource(
client.networks,
parsed_args.network,
)
columns = sorted(network._info.keys())
data = utils.get_dict_properties(network._info, columns)
return (columns, data)
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
group = utils.find_resource(compute_client.server_groups,
parsed_args.server_group)
info = {}
info.update(group._info)
columns = _get_columns(info)
data = utils.get_dict_properties(info, columns, formatters=_formatters)
return columns, data
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
info = {}
server_group = compute_client.server_groups.create(
name=parsed_args.name, policies=parsed_args.policy)
info.update(server_group._info)
columns = _get_columns(info)
data = utils.get_dict_properties(info, columns, formatters=_formatters)
return columns, data
def take_action_compute(self, client, parsed_args):
obj = utils.find_resource(
client.security_groups,
parsed_args.group,
)
display_columns, property_columns = _get_columns(obj._info)
data = utils.get_dict_properties(obj._info,
property_columns,
formatters=_formatters_compute)
return (display_columns, data)
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
group = utils.find_resource(compute_client.server_groups,
parsed_args.server_group)
info = {}
info.update(group._info)
columns = _get_columns(info)
data = utils.get_dict_properties(info, columns,
formatters=_formatters)
return columns, data
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)
client = self.app.client_manager.messaging
queue_name = parsed_args.queue_name
queue = client.queue(queue_name, auto_create=False)
columns = ('Exists',)
data = dict(exists=queue.exists())
return columns, utils.get_dict_properties(data, columns)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
try:
event = senlin_client.get_event(parsed_args.event)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_("Event not found: %s")
% parsed_args.event)
columns = sorted(list(six.iterkeys(event)))
return columns, utils.get_dict_properties(event.to_dict(), columns)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
try:
event = senlin_client.get_event(parsed_args.event)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(
_("Event not found: %s") % parsed_args.event)
columns = list(six.iterkeys(event))
return columns, utils.get_dict_properties(event.to_dict(), columns)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.messaging
queue_name = parsed_args.queue_name
queue = client.queue(queue_name, auto_create=False)
columns = ('Exists', )
data = dict(exists=queue.exists())
return columns, utils.get_dict_properties(data, columns)
def take_action_compute(self, client, parsed_args):
description = self._get_description(parsed_args)
obj = client.security_groups.create(
parsed_args.name,
description,
)
display_columns, property_columns = _get_columns(obj._info)
data = utils.get_dict_properties(obj._info,
property_columns,
formatters=_formatters_compute)
return (display_columns, data)
def take_action(self, parsed_args):
compute_client = self.app.client_manager.compute
info = {}
server_group = compute_client.server_groups.create(
name=parsed_args.name,
policies=parsed_args.policy)
info.update(server_group._info)
columns = _get_columns(info)
data = utils.get_dict_properties(info, columns,
formatters=_formatters)
return columns, data
def take_action_compute(self, client, parsed_args):
obj = utils.find_resource(
client.security_groups,
parsed_args.group,
)
display_columns, property_columns = _get_columns(obj._info)
data = utils.get_dict_properties(
obj._info,
property_columns,
formatters=_formatters_compute
)
return (display_columns, data)
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 take_action(self, parsed_args):
self.log.debug("take_action(%s)", 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_compute(self, client, parsed_args):
description = self._get_description(parsed_args)
obj = client.security_groups.create(
parsed_args.name,
description,
)
display_columns, property_columns = _get_columns(obj._info)
data = utils.get_dict_properties(
obj._info,
property_columns,
formatters=_formatters_compute
)
return (display_columns, data)
def _show_cluster(senlin_client, cluster_id):
try:
cluster = senlin_client.get_cluster(cluster_id)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_('Cluster not found: %s') % cluster_id)
formatters = {
'metadata': senlin_utils.json_formatter,
'nodes': senlin_utils.list_formatter
}
columns = list(six.iterkeys(cluster))
return columns, utils.get_dict_properties(cluster.to_dict(), columns,
formatters=formatters)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
result = senlin_client.get_build_info()
formatters = {
'api': senlin_utils.json_formatter,
'engine': senlin_utils.json_formatter,
}
columns = sorted(list(six.iterkeys(result)))
return columns, utils.get_dict_properties(result.to_dict(), columns,
formatters=formatters)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
search_client = self.app.client_manager.search
mapping = {"_score": "score", "_type": "type", "_id": "id",
"_index": "index", "_source": "source"}
params = {
"type": parsed_args.type,
"all_projects": parsed_args.all_projects
}
source = parsed_args.source
if source:
columns = ("ID", "Score", "Type", "Source")
if source != "all_sources":
params["_source"] = (["id"] +
[s for s in source.split(",") if s != 'id'])
else:
columns = ("ID", "Name", "Score", "Type", "Updated")
# Only return the required fields when source not specified.
params["_source"] = ["id", "name", "updated_at"]
if parsed_args.query:
if parsed_args.json:
query = json.loads(parsed_args.query)
else:
try:
json.loads(parsed_args.query)
print("You should use the --json flag when specifying "
"a JSON object.")
exit(1)
except Exception:
qs = self._modify_query_string(parsed_args.query)
query = {"query_string": {"query": qs}}
params['query'] = query
data = search_client.search.search(**params)
result = []
for r in data.hits['hits']:
converted = {}
# hit._id may include extra information appended after _,
# so use r['_source']['id'] for safe.
r['_id'] = r.get('_source', {}).get('id')
for k, v in six.iteritems(r):
converted[mapping[k]] = v
if k == "_source" and not parsed_args.source:
converted["name"] = v.get("name")
converted["updated"] = v.get("updated_at")
result.append(utils.get_dict_properties(converted, columns))
return (columns, result)
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):
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):
self.log.debug("take_action(%s)" % parsed_args)
client = self.app.client_manager.messaging
queue_name = parsed_args.queue_name
queue = client.queue(queue_name, auto_create=False)
if not queue.exists():
raise RuntimeError('Queue(%s) does not exist.' % queue_name)
columns = ("Stats", )
data = dict(stats=queue.stats)
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.messaging
queue_name = parsed_args.queue_name
queue = client.queue(queue_name, auto_create=False)
if not queue.exists():
raise RuntimeError('Queue(%s) does not exist.' % queue_name)
columns = ("Stats",)
data = dict(stats=queue.stats)
return columns, utils.get_dict_properties(data, columns)
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 _show_policy(senlin_client, policy_id):
try:
policy = senlin_client.get_policy(policy_id)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_('Policy not found: %s') % policy_id)
formatters = {'spec': senlin_utils.json_formatter}
columns = [
'created_at', 'data', 'domain', 'id', 'name', 'project', 'spec',
'type', 'updated_at', 'user'
]
return columns, utils.get_dict_properties(policy.to_dict(),
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 _show_receiver(senlin_client, receiver_id):
try:
receiver = senlin_client.get_receiver(receiver_id)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_('Receiver not found: %s') % receiver_id)
formatters = {
'actor': senlin_utils.json_formatter,
'params': senlin_utils.json_formatter,
'channel': senlin_utils.json_formatter,
}
columns = sorted(list(six.iterkeys(receiver)))
return columns, utils.get_dict_properties(receiver.to_dict(), columns,
formatters=formatters)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
result = senlin_client.get_build_info()
formatters = {
'api': senlin_utils.json_formatter,
'engine': senlin_utils.json_formatter,
}
columns = list(six.iterkeys(result))
return columns, utils.get_dict_properties(result.to_dict(),
columns,
formatters=formatters)
def _show_receiver(senlin_client, receiver_id):
try:
receiver = senlin_client.get_receiver(receiver_id)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_('Receiver not found: %s') % receiver_id)
formatters = {
'actor': senlin_utils.json_formatter,
'params': senlin_utils.json_formatter,
'channel': senlin_utils.json_formatter,
}
columns = list(six.iterkeys(receiver))
return columns, utils.get_dict_properties(receiver.to_dict(), columns,
formatters=formatters)
def _show_cluster(senlin_client, cluster_id):
try:
cluster = senlin_client.get_cluster(cluster_id)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_('Cluster not found: %s') % cluster_id)
formatters = {
'metadata': senlin_utils.json_formatter,
'nodes': senlin_utils.list_formatter
}
columns = list(six.iterkeys(cluster))
return columns, utils.get_dict_properties(cluster.to_dict(),
columns,
formatters=formatters)
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):
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 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):
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):
self.log.debug('take_action(%s)' % parsed_args)
client = self.app.client_manager.network
if parsed_args.dhcp:
data = client.api.dhcp_agent_list(dhcp_id=parsed_args.dhcp)
columns = ('ID', )
column_headers = columns
else:
data = client.api.network_list(external=parsed_args.external)
if parsed_args.long:
columns = (
'ID',
'Name',
'Status',
'project_id',
'state',
'Shared',
'Subnets',
'provider:network_type',
'router_type',
)
column_headers = (
'ID',
'Name',
'Status',
'Project',
'State',
'Shared',
'Subnets',
'Network Type',
'Router Type',
)
else:
columns = ('ID', 'Name', 'Subnets')
column_headers = columns
for d in data:
d = _prep_network_detail(d)
return (column_headers, (utils.get_dict_properties(
s,
columns,
formatters={'subnets': utils.format_list},
) for s in data))
def take_action(self, parsed_args):
self.log.debug('take_action(%s)' % parsed_args)
client = self.app.client_manager.network
if parsed_args.dhcp:
data = client.api.dhcp_agent_list(dhcp_id=parsed_args.dhcp)
columns = ('ID',)
column_headers = columns
else:
data = client.api.network_list(external=parsed_args.external)
if parsed_args.long:
columns = (
'ID',
'Name',
'Status',
'project_id',
'state',
'Shared',
'Subnets',
'provider:network_type',
'router_type',
)
column_headers = (
'ID',
'Name',
'Status',
'Project',
'State',
'Shared',
'Subnets',
'Network Type',
'Router Type',
)
else:
columns = ('ID', 'Name', 'Subnets')
column_headers = columns
for d in data:
d = _prep_network_detail(d)
return (column_headers,
(utils.get_dict_properties(
s, columns,
formatters={'subnets': utils.format_list},
) for s in data))
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
results = []
for container in parsed_args.containers:
data = lib_container.create_container(
self.app.client_manager.session,
self.app.client_manager.object_store.endpoint,
container,
)
results.append(data)
columns = ("account", "container", "x-trans-id")
return (columns, (utils.get_dict_properties(
s,
columns,
formatters={},
) for s in results))
def _show_profile(senlin_client, profile_id):
try:
data = senlin_client.get_profile(profile_id)
except sdk_exc.ResourceNotFound:
raise exc.CommandError('Profile not found: %s' % profile_id)
else:
formatters = {}
formatters['metadata'] = senlin_utils.json_formatter
formatters['spec'] = senlin_utils.nested_dict_formatter(
['type', 'version', 'properties'], ['property', 'value'])
columns = [
'created_at', 'domain', 'id', 'metadata', 'name', 'project',
'spec', 'type', 'updated_at', 'user'
]
return columns, utils.get_dict_properties(data.to_dict(),
columns,
formatters=formatters)
def take_action(self, parsed_args):
self.log.debug('take_action(%s)', parsed_args)
results = []
for obj in parsed_args.objects:
data = lib_object.create_object(
self.app.client_manager.session,
self.app.client_manager.object_store.endpoint,
parsed_args.container,
obj,
)
results.append(data)
columns = ("object", "container", "etag")
return (columns, (utils.get_dict_properties(
s,
columns,
formatters={},
) for s in results))
