def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
columns = ['id', 'name', 'index', 'status', 'cluster_id',
'physical_id', 'profile_name', 'created_at', 'updated_at']
queries = {
'cluster_id': parsed_args.cluster,
'sort': parsed_args.sort,
'limit': parsed_args.limit,
'marker': parsed_args.marker,
'global_project': parsed_args.global_project,
}
if parsed_args.filters:
queries.update(senlin_utils.format_parameters(parsed_args.filters))
nodes = senlin_client.nodes(**queries)
if not parsed_args.full_id:
formatters = {
'id': lambda x: x[:8],
'cluster_id': lambda x: x[:8] if x else '',
'physical_id': lambda x: x[:8] if x else ''
}
else:
formatters = {}
return (
columns,
(utils.get_item_properties(n, columns, formatters=formatters)
for n in nodes)
)
def do_cluster_list(service, args=None):
"""List the user's clusters."""
fields = ['id', 'name', 'status', 'created_at', 'updated_at']
queries = {
'limit': args.limit,
'marker': args.marker,
'sort': args.sort,
'show_nested': args.show_nested,
'global_project': args.global_project,
}
if args.filters:
queries.update(utils.format_parameters(args.filters))
if args.show_nested:
fields.append('parent')
sortby_index = None if args.sort else 3
clusters = service.clusters(**queries)
formatters = {}
if not args.full_id:
formatters = {
'id': lambda x: x.id[:8]
}
utils.print_list(clusters, fields, formatters=formatters,
sortby_index=sortby_index)
def do_node_list(service, args):
"""Show list of nodes."""
fields = ['id', 'name', 'index', 'status', 'cluster_id', 'physical_id',
'profile_name', 'created_at', 'updated_at']
queries = {
'cluster_id': args.cluster,
'sort': args.sort,
'limit': args.limit,
'marker': args.marker,
'global_project': args.global_project,
}
if args.filters:
queries.update(utils.format_parameters(args.filters))
sortby_index = None if args.sort else 6
nodes = service.nodes(**queries)
if not args.full_id:
formatters = {
'id': lambda x: x.id[:8],
'cluster_id': lambda x: x.cluster_id[:8] if x.cluster_id else '',
'physical_id': lambda x: x.physical_id[:8] if x.physical_id else ''
}
else:
formatters = {}
utils.print_list(nodes, fields, formatters=formatters,
sortby_index=sortby_index)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
columns = ['id', 'name', 'status', 'created_at', 'updated_at']
queries = {
'limit': parsed_args.limit,
'marker': parsed_args.marker,
'sort': parsed_args.sort,
'global_project': parsed_args.global_project,
}
if parsed_args.filters:
queries.update(senlin_utils.format_parameters(parsed_args.filters))
clusters = senlin_client.clusters(**queries)
formatters = {}
if parsed_args.global_project:
columns.append('project_id')
if not parsed_args.full_id:
formatters = {
'id': lambda x: x[:8]
}
if 'project_id' in columns:
formatters['project_id'] = lambda x: x[:8]
return (
columns,
(utils.get_item_properties(c, columns, formatters=formatters)
for c in clusters)
)
def do_profile_create(service, args):
"""Create a profile."""
spec = utils.get_spec_content(args.spec_file)
type_name = spec.get('type', None)
type_version = spec.get('version', None)
properties = spec.get('properties', None)
if type_name is None:
raise exc.CommandError(_("Missing 'type' key in spec file."))
if type_version is None:
raise exc.CommandError(_("Missing 'version' key in spec file."))
if properties is None:
raise exc.CommandError(_("Missing 'properties' key in spec file."))
if type_name == 'os.heat.stack':
stack_properties = utils.process_stack_spec(properties)
spec['properties'] = stack_properties
params = {
'name': args.name,
'spec': spec,
'metadata': utils.format_parameters(args.metadata),
}
profile = service.create_profile(**params)
_show_profile(service, profile.id)
def do_cluster_node_list(service, args):
"""List nodes from cluster."""
queries = {
'cluster_id': args.id,
'limit': args.limit,
'marker': args.marker,
}
if args.filters:
queries.update(utils.format_parameters(args.filters))
try:
nodes = service.nodes(**queries)
except exc.HTTPNotFound:
msg = _('No node matching criteria is found')
raise exc.CommandError(msg)
if not args.full_id:
formatters = {
'id': lambda x: x.id[:8],
'physical_id': lambda x: x.physical_id[:8] if x.physical_id else ''
}
else:
formatters = {}
fields = ['id', 'name', 'index', 'status', 'physical_id', 'created_at']
utils.print_list(nodes, fields, formatters=formatters, sortby_index=5)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
spec = senlin_utils.get_spec_content(parsed_args.spec_file)
type_name = spec.get('type', None)
type_version = spec.get('version', None)
properties = spec.get('properties', None)
if type_name is None:
raise exc.CommandError(_("Missing 'type' key in spec file."))
if type_version is None:
raise exc.CommandError(_("Missing 'version' key in spec file."))
if properties is None:
raise exc.CommandError(_("Missing 'properties' key in spec file."))
if type_name == 'os.heat.stack':
stack_properties = senlin_utils.process_stack_spec(properties)
spec['properties'] = stack_properties
params = {
'name': parsed_args.name,
'spec': spec,
'metadata': senlin_utils.format_parameters(parsed_args.metadata),
}
profile = senlin_client.create_profile(**params)
return _show_profile(senlin_client, profile_id=profile.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
columns = ['id', 'name', 'type', 'created_at']
queries = {
'limit': parsed_args.limit,
'marker': parsed_args.marker,
'sort': parsed_args.sort,
'global_project': parsed_args.global_project,
}
if parsed_args.filters:
queries.update(senlin_utils.format_parameters(parsed_args.filters))
policies = senlin_client.policies(**queries)
formatters = {}
if not parsed_args.full_id:
formatters = {
'id': lambda x: x[:8]
}
return (
columns,
(utils.get_item_properties(p, columns, formatters=formatters)
for p in policies)
)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
columns = [
'id', 'generated_at', 'obj_type', 'obj_id', 'obj_name', 'action',
'status', 'level', 'cluster_id'
]
queries = {
'sort': parsed_args.sort,
'limit': parsed_args.limit,
'marker': parsed_args.marker,
'global_project': parsed_args.global_project,
}
if parsed_args.filters:
queries.update(senlin_utils.format_parameters(parsed_args.filters))
formatters = {}
if parsed_args.global_project:
columns.append('project_id')
if not parsed_args.full_id:
formatters['id'] = lambda x: x[:8]
formatters['obj_id'] = lambda x: x[:8] if x else ''
if 'project_id' in columns:
formatters['project_id'] = lambda x: x[:8]
formatters['cluster_id'] = lambda x: x[:8] if x else ''
events = senlin_client.events(**queries)
return (columns, (utils.get_item_properties(e,
columns,
formatters=formatters)
for e in events))
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
columns = ['id', 'timestamp', 'obj_type', 'obj_id', 'obj_name',
'action', 'status', 'status_reason', 'level']
queries = {
'sort': parsed_args.sort,
'limit': parsed_args.limit,
'marker': parsed_args.marker,
'global_project': parsed_args.global_project,
}
if parsed_args.filters:
queries.update(senlin_utils.format_parameters(parsed_args.filters))
formatters = {}
if not parsed_args.full_id:
formatters['id'] = lambda x: x[:8]
formatters['obj_id'] = lambda x: x[:8] if x else ''
events = senlin_client.events(**queries)
return (
columns,
(utils.get_item_properties(e, columns, formatters=formatters)
for e in events)
)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
spec = senlin_utils.get_spec_content(parsed_args.spec_file)
type_name = spec.get('type', None)
type_version = spec.get('version', None)
properties = spec.get('properties', None)
if type_name is None:
raise exc.CommandError(_("Missing 'type' key in spec file."))
if type_version is None:
raise exc.CommandError(_("Missing 'version' key in spec file."))
if properties is None:
raise exc.CommandError(_("Missing 'properties' key in spec file."))
if type_name == 'os.heat.stack':
stack_properties = senlin_utils.process_stack_spec(properties)
spec['properties'] = stack_properties
params = {
'name': parsed_args.name,
'spec': spec,
'metadata': senlin_utils.format_parameters(parsed_args.metadata),
}
profile = senlin_client.create_profile(**params)
return _show_profile(senlin_client, profile_id=profile.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
columns = ['id', 'name', 'type', 'cluster_id', 'action', 'created_at']
queries = {
'limit': parsed_args.limit,
'marker': parsed_args.marker,
'sort': parsed_args.sort,
'global_project': parsed_args.global_project,
}
if parsed_args.filters:
queries.update(senlin_utils.format_parameters(parsed_args.filters))
receivers = senlin_client.receivers(**queries)
formatters = {}
if not parsed_args.full_id:
formatters = {
'id': lambda x: x[:8],
'cluster_id': lambda x: x[:8],
}
return (
columns,
(utils.get_item_properties(r, columns, formatters=formatters)
for r in receivers)
)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
queries = {
'cluster_id': parsed_args.cluster,
'sort': parsed_args.sort,
'limit': parsed_args.limit,
'marker': parsed_args.marker,
}
if parsed_args.filters:
queries.update(senlin_utils.format_parameters(parsed_args.filters))
nodes = senlin_client.nodes(**queries)
if not parsed_args.full_id:
formatters = {
'id': lambda x: x[:8],
'physical_id': lambda x: x[:8] if x else ''
}
else:
formatters = {}
columns = ['id', 'name', 'index', 'status', 'physical_id',
'created_at']
return (
columns,
(utils.get_item_properties(n, columns, formatters=formatters)
for n in nodes)
)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
# Find the node first, we need its UUID
node = senlin_client.find_node(parsed_args.node)
if node is None:
raise exc.CommandError(_('Node not found: %s') % parsed_args.node)
attrs = {
'name': parsed_args.name,
'role': parsed_args.role,
'profile_id': parsed_args.profile,
'metadata': senlin_utils.format_parameters(parsed_args.metadata),
}
if parsed_args.tainted is not None:
attrs['tainted'] = strutils.bool_from_string(
parsed_args.tainted,
strict=True,
)
senlin_client.update_node(node.id, **attrs)
return _show_node(senlin_client, node.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
if parsed_args.min_size and not parsed_args.desired_capacity:
parsed_args.desired_capacity = parsed_args.min_size
attrs = {
'config': senlin_utils.format_parameters(parsed_args.config),
'name': parsed_args.name,
'profile_id': parsed_args.profile,
'min_size': parsed_args.min_size,
'max_size': parsed_args.max_size,
'desired_capacity': parsed_args.desired_capacity,
'metadata': senlin_utils.format_parameters(parsed_args.metadata),
'timeout': parsed_args.timeout
}
cluster = senlin_client.create_cluster(**attrs)
return _show_cluster(senlin_client, cluster.id)
def do_cluster_update(service, args):
"""Update the cluster."""
cluster = service.get_cluster(args.id)
attrs = {
'name': args.name,
'profile_id': args.profile,
'metadata': utils.format_parameters(args.metadata),
'timeout': args.timeout,
}
service.update_cluster(cluster.id, **attrs)
_show_cluster(service, cluster.id)
def do_node_create(service, args):
"""Create the node."""
attrs = {
'name': args.name,
'cluster_id': args.cluster,
'profile_id': args.profile,
'role': args.role,
'metadata': utils.format_parameters(args.metadata),
}
node = service.create_node(**attrs)
_show_node(service, node.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
cluster = senlin_client.get_cluster(parsed_args.cluster)
attrs = {
'name': parsed_args.name,
'profile_id': parsed_args.profile,
'metadata': senlin_utils.format_parameters(parsed_args.metadata),
'timeout': parsed_args.timeout,
}
senlin_client.update_cluster(cluster.id, **attrs)
return _show_cluster(senlin_client, cluster.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
cluster = senlin_client.get_cluster(parsed_args.cluster)
attrs = {
'name': parsed_args.name,
'profile_id': parsed_args.profile,
'metadata': senlin_utils.format_parameters(parsed_args.metadata),
'timeout': parsed_args.timeout,
}
senlin_client.update_cluster(cluster.id, **attrs)
return _show_cluster(senlin_client, cluster.id)
def do_receiver_create(service, args):
"""Create a receiver."""
params = {
'name': args.name,
'type': args.type,
'cluster_id': args.cluster,
'action': args.action,
'params': utils.format_parameters(args.params)
}
receiver = service.create_receiver(**params)
_show_receiver(service, receiver.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
params = {
'name': parsed_args.name,
'type': parsed_args.type,
'cluster_id': parsed_args.cluster,
'action': parsed_args.action,
'params': senlin_utils.format_parameters(parsed_args.params)
}
receiver = senlin_client.create_receiver(**params)
return _show_receiver(senlin_client, receiver.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
params = {
'name': parsed_args.name,
'type': parsed_args.type,
'cluster_id': parsed_args.cluster,
'action': parsed_args.action,
'params': senlin_utils.format_parameters(parsed_args.params)
}
receiver = senlin_client.create_receiver(**params)
return _show_receiver(senlin_client, receiver.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
attrs = {
'name': parsed_args.name,
'cluster_id': parsed_args.cluster,
'profile_id': parsed_args.profile,
'role': parsed_args.role,
'metadata': senlin_utils.format_parameters(parsed_args.metadata),
}
node = senlin_client.create_node(**attrs)
return _show_node(senlin_client, node.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
attrs = {
'name': parsed_args.name,
'cluster_id': parsed_args.cluster,
'profile_id': parsed_args.profile,
'role': parsed_args.role,
'metadata': senlin_utils.format_parameters(parsed_args.metadata),
}
node = senlin_client.create_node(**attrs)
return _show_node(senlin_client, node.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
cid = parsed_args.cluster
if parsed_args.params:
params = senlin_utils.format_parameters(parsed_args.params)
else:
params = {}
try:
resp = senlin_client.perform_operation_on_cluster(
cid, parsed_args.operation, **params)
print('Request accepted by action: %s' % resp['action'])
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_('Cluster not found: %s') % cid)
def do_profile_update(service, args):
"""Update a profile."""
params = {
'name': args.name,
}
if args.metadata:
params['metadata'] = utils.format_parameters(args.metadata)
# Find the profile first, we need its id
try:
profile = service.get_profile(args.id)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_('Profile not found: %s') % args.id)
service.update_profile(profile.id, **params)
_show_profile(service, profile.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
cluster = senlin_client.find_cluster(parsed_args.cluster)
if cluster is None:
raise exc.CommandError(_('Cluster not found: %s') %
parsed_args.cluster)
attrs = {
'name': parsed_args.name,
'profile_id': parsed_args.profile,
'metadata': senlin_utils.format_parameters(parsed_args.metadata),
'timeout': parsed_args.timeout,
}
senlin_client.update_cluster(cluster.id, **attrs)
return _show_cluster(senlin_client, cluster.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
params = {
'name': parsed_args.name,
'action': parsed_args.action,
'params': senlin_utils.format_parameters(parsed_args.params)
}
receiver = senlin_client.find_receiver(parsed_args.receiver)
if receiver is None:
raise exc.CommandError(
_('Receiver not found: %s') % parsed_args.receiver)
senlin_client.update_receiver(receiver.id, **params)
return _show_receiver(senlin_client, receiver_id=receiver.id)
def do_cluster_create(service, args):
"""Create the cluster."""
if args.min_size and not args.desired_capacity:
args.desired_capacity = args.min_size
attrs = {
'name': args.name,
'profile_id': args.profile,
'min_size': args.min_size,
'max_size': args.max_size,
'desired_capacity': args.desired_capacity,
'metadata': utils.format_parameters(args.metadata),
'timeout': args.timeout
}
cluster = service.create_cluster(**attrs)
_show_cluster(service, cluster.id)
def do_node_update(service, args):
"""Update the node."""
# Find the node first, we need its UUID
try:
node = service.get_node(args.id)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_('Node not found: %s') % args.id)
attrs = {
'name': args.name,
'role': args.role,
'profile_id': args.profile,
'metadata': utils.format_parameters(args.metadata),
}
service.update_node(args.id, **attrs)
_show_node(service, node.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
params = {
'name': parsed_args.name,
}
if parsed_args.metadata:
params['metadata'] = senlin_utils.format_parameters(
parsed_args.metadata)
# Find the profile first, we need its id
profile = senlin_client.find_profile(parsed_args.profile)
if profile is None:
raise exc.CommandError(
_('Profile not found: %s') % parsed_args.profile)
senlin_client.update_profile(profile.id, **params)
return _show_profile(senlin_client, profile_id=profile.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
params = {
'name': parsed_args.name,
}
if parsed_args.metadata:
params['metadata'] = senlin_utils.format_parameters(
parsed_args.metadata)
# Find the profile first, we need its id
profile = senlin_client.find_profile(parsed_args.profile)
if profile is None:
raise exc.CommandError(_('Profile not found: %s') %
parsed_args.profile)
senlin_client.update_profile(profile.id, **params)
return _show_profile(senlin_client, profile_id=profile.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
if parsed_args.min_size and not parsed_args.desired_capacity:
parsed_args.desired_capacity = parsed_args.min_size
attrs = {
'name': parsed_args.name,
'profile_id': parsed_args.profile,
'min_size': parsed_args.min_size,
'max_size': parsed_args.max_size,
'desired_capacity': parsed_args.desired_capacity,
'metadata': senlin_utils.format_parameters(parsed_args.metadata),
'timeout': parsed_args.timeout
}
cluster = senlin_client.create_cluster(**attrs)
return _show_cluster(senlin_client, cluster.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
if parsed_args.type == 'webhook':
if (not parsed_args.cluster or not parsed_args.action):
msg = _('cluster and action parameters are required to create '
'webhook type of receiver.')
raise exc.CommandError(msg)
senlin_client = self.app.client_manager.clustering
params = {
'name': parsed_args.name,
'type': parsed_args.type,
'cluster_id': parsed_args.cluster,
'action': parsed_args.action,
'params': senlin_utils.format_parameters(parsed_args.params)
}
receiver = senlin_client.create_receiver(**params)
return _show_receiver(senlin_client, receiver.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
# Find the node first, we need its UUID
try:
node = senlin_client.get_node(parsed_args.node)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_('Node not found: %s') % parsed_args.node)
attrs = {
'name': parsed_args.name,
'role': parsed_args.role,
'profile_id': parsed_args.profile,
'metadata': senlin_utils.format_parameters(parsed_args.metadata),
}
senlin_client.update_node(parsed_args.node, **attrs)
return _show_node(senlin_client, node.id)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
# Find the node first, we need its UUID
try:
node = senlin_client.get_node(parsed_args.node)
except sdk_exc.ResourceNotFound:
raise exc.CommandError(_('Node not found: %s') % parsed_args.node)
attrs = {
'name': parsed_args.name,
'role': parsed_args.role,
'profile_id': parsed_args.profile,
'metadata': senlin_utils.format_parameters(parsed_args.metadata),
}
senlin_client.update_node(parsed_args.node, **attrs)
return _show_node(senlin_client, node.id)
def do_policy_list(service, args=None):
"""List policies that meet the criteria."""
fields = ['id', 'name', 'type', 'created_at']
queries = {
'limit': args.limit,
'marker': args.marker,
'sort': args.sort,
'global_project': args.global_project,
}
if args.filters:
queries.update(utils.format_parameters(args.filters))
sortby_index = None if args.sort else 1
policies = service.policies(**queries)
formatters = {}
if not args.full_id:
formatters = {
'id': lambda x: x.id[:8]
}
utils.print_list(policies, fields, formatters=formatters,
sortby_index=sortby_index)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
columns = ['policy_id', 'policy_name', 'policy_type', 'is_enabled']
cluster = senlin_client.get_cluster(parsed_args.cluster)
queries = {
'sort': parsed_args.sort,
}
if parsed_args.filters:
queries.update(senlin_utils.format_parameters(parsed_args.filters))
policies = senlin_client.cluster_policies(cluster.id, **queries)
formatters = {}
if not parsed_args.full_id:
formatters = {'policy_id': lambda x: x[:8]}
return (columns, (utils.get_item_properties(p,
columns,
formatters=formatters)
for p in policies))
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
columns = [
'id', 'name', 'action', 'status', 'target', 'depends_on',
'depended_by', 'created_at'
]
queries = {
'sort': parsed_args.sort,
'limit': parsed_args.limit,
'marker': parsed_args.marker,
}
if parsed_args.filters:
queries.update(senlin_utils.format_parameters(parsed_args.filters))
actions = senlin_client.actions(**queries)
formatters = {}
if parsed_args.full_id:
f_depon = lambda x: '\n'.join(a for a in x)
f_depby = lambda x: '\n'.join(a for a in x)
formatters['depends_on'] = f_depon
formatters['depended_by'] = f_depby
else:
formatters['id'] = lambda x: x[:8]
formatters['target'] = lambda x: x[:8]
f_depon = lambda x: '\n'.join(a[:8] for a in x)
f_depby = lambda x: '\n'.join(a[:8] for a in x)
formatters['depends_on'] = f_depon
formatters['depended_by'] = f_depby
return (columns, (utils.get_item_properties(a,
columns,
formatters=formatters)
for a in actions))
def do_cluster_list(service, args=None):
"""List the user's clusters."""
fields = ['id', 'name', 'status', 'created_at', 'updated_at']
queries = {
'limit': args.limit,
'marker': args.marker,
'sort': args.sort,
'global_project': args.global_project,
}
if args.filters:
queries.update(utils.format_parameters(args.filters))
sortby_index = None if args.sort else 3
clusters = service.clusters(**queries)
formatters = {}
if not args.full_id:
formatters = {
'id': lambda x: x.id[:8]
}
utils.print_list(clusters, fields, formatters=formatters,
sortby_index=sortby_index)
def do_cluster_node_list(service, args):
"""List nodes from cluster."""
queries = {
'cluster_id': args.id,
'limit': args.limit,
'marker': args.marker,
}
if args.filters:
queries.update(utils.format_parameters(args.filters))
nodes = service.nodes(**queries)
if not args.full_id:
formatters = {
'id': lambda x: x.id[:8],
'physical_id': lambda x: x.physical_id[:8] if x.physical_id else ''
}
else:
formatters = {}
fields = ['id', 'name', 'index', 'status', 'physical_id', 'created_at']
utils.print_list(nodes, fields, formatters=formatters, sortby_index=5)
def do_cluster_policy_list(service, args):
"""List policies from cluster."""
fields = ['policy_id', 'policy_name', 'policy_type', 'enabled']
cluster = service.get_cluster(args.id)
queries = {
'sort': args.sort,
}
if args.filters:
queries.update(utils.format_parameters(args.filters))
sortby_index = None if args.sort else 3
policies = service.cluster_policies(cluster.id, **queries)
formatters = {}
if not args.full_id:
formatters = {
'policy_id': lambda x: x.id[:8]
}
utils.print_list(policies, fields, formatters=formatters,
sortby_index=sortby_index)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
columns = ['id', 'name', 'action', 'status', 'target', 'depends_on',
'depended_by', 'created_at']
queries = {
'sort': parsed_args.sort,
'limit': parsed_args.limit,
'marker': parsed_args.marker,
}
if parsed_args.filters:
queries.update(senlin_utils.format_parameters(parsed_args.filters))
actions = senlin_client.actions(**queries)
formatters = {}
if parsed_args.full_id:
f_depon = lambda x: '\n'.join(a for a in x)
f_depby = lambda x: '\n'.join(a for a in x)
formatters['depends_on'] = f_depon
formatters['depended_by'] = f_depby
else:
formatters['id'] = lambda x: x[:8]
formatters['target'] = lambda x: x[:8]
f_depon = lambda x: '\n'.join(a[:8] for a in x)
f_depby = lambda x: '\n'.join(a[:8] for a in x)
formatters['depends_on'] = f_depon
formatters['depended_by'] = f_depby
return (
columns,
(utils.get_item_properties(a, columns, formatters=formatters)
for a in actions)
)
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
senlin_client = self.app.client_manager.clustering
columns = ['policy_id', 'policy_name', 'policy_type', 'enabled']
cluster = senlin_client.get_cluster(parsed_args.cluster)
queries = {
'sort': parsed_args.sort,
}
if parsed_args.filters:
queries.update(senlin_utils.format_parameters(parsed_args.filters))
policies = senlin_client.cluster_policies(cluster.id, **queries)
formatters = {}
if not parsed_args.full_id:
formatters = {
'policy_id': lambda x: x[:8]
}
return (
columns,
(utils.get_item_properties(p, columns, formatters=formatters)
for p in policies)
)
def do_event_list(service, args):
"""List events."""
fields = ['id', 'timestamp', 'obj_type', 'obj_id', 'obj_name', 'action',
'status', 'status_reason', 'level']
queries = {
'sort': args.sort,
'limit': args.limit,
'marker': args.marker,
'global_project': args.global_project,
}
if args.filters:
queries.update(utils.format_parameters(args.filters))
sortby_index = None if args.sort else 0
formatters = {}
if not args.full_id:
formatters['id'] = lambda x: x.id[:8]
formatters['obj_id'] = lambda x: x.obj_id[:8] if x.obj_id else ''
events = service.events(**queries)
utils.print_list(events, fields, formatters=formatters,
sortby_index=sortby_index)
def do_action_list(service, args):
"""List actions."""
fields = ['id', 'name', 'action', 'status', 'target', 'depends_on',
'depended_by', 'created_at']
queries = {
'sort': args.sort,
'limit': args.limit,
'marker': args.marker,
}
if args.filters:
queries.update(utils.format_parameters(args.filters))
sortby_index = None if args.sort else 0
actions = service.actions(**queries)
formatters = {}
if args.full_id:
f_depon = lambda x: '\n'.join(a for a in x.depends_on)
f_depby = lambda x: '\n'.join(a for a in x.depended_by)
formatters['depends_on'] = f_depon
formatters['depended_by'] = f_depby
else:
formatters['id'] = lambda x: x.id[:8]
formatters['target'] = lambda x: x.target[:8]
f_depon = lambda x: '\n'.join(a[:8] for a in x.depends_on)
f_depby = lambda x: '\n'.join(a[:8] for a in x.depended_by)
formatters['depends_on'] = f_depon
formatters['depended_by'] = f_depby
utils.print_list(actions, fields, formatters=formatters,
sortby_index=sortby_index)
def do_receiver_list(service, args):
"""List receivers that meet the criteria."""
fields = ['id', 'name', 'type', 'cluster_id', 'action', 'created_at']
queries = {
'limit': args.limit,
'marker': args.marker,
'sort': args.sort,
'global_project': args.global_project,
}
if args.filters:
queries.update(utils.format_parameters(args.filters))
sortby_index = None if args.sort else 0
receivers = service.receivers(**queries)
formatters = {}
if not args.full_id:
formatters = {
'id': lambda x: x.id[:8],
'cluster_id': lambda x: x.cluster_id[:8],
}
utils.print_list(receivers, fields, formatters=formatters,
sortby_index=sortby_index)
def test_format_parameter_split(self):
params = ['status=ACTIVE', 'name=cluster1']
format_params = {'status': 'ACTIVE', 'name': 'cluster1'}
self.assertEqual(format_params,
utils.format_parameters(params))
def test_format_parameter_none(self):
self.assertEqual({}, utils.format_parameters(None))
