Switch to use SDK calls in client
This patch revises more calls from client side to use SDK interface. Change-Id: I3ec4c3e7315f204d4eb6022bed63abd6b28e8157
This commit is contained in:
tengqm
parent
6bcf949e5b
commit
d14f733765
@ -291,7 +291,7 @@ class SenlinShell(object):
|
||||
if profile:
|
||||
osprofiler_profiler.init(options.profile)
|
||||
|
||||
args.func(sc, args)
|
||||
args.func(sc.service, args)
|
||||
|
||||
if profile:
|
||||
trace_id = osprofiler_profiler.get().get_base_id()
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -10,267 +10,153 @@
|
||||
# License for the specific language governing permissions and limitations
|
||||
# under the License.
|
||||
|
||||
import inspect
|
||||
from openstack.identity import identity_service
|
||||
|
||||
from senlinclient.common import exc as client_exc
|
||||
from senlinclient.common import sdk
|
||||
from senlinclient.v1 import models
|
||||
|
||||
|
||||
class Client(object):
|
||||
|
||||
def __init__(self, preferences=None, user_agent=None, **kwargs):
|
||||
self.conn = sdk.create_connection(preferences, user_agent, **kwargs)
|
||||
# TODO(Qiming): delete this
|
||||
self.session = self.conn.session
|
||||
self.service = self.conn.cluster
|
||||
|
||||
######################################################################
|
||||
# The following operations are interfaces exposed to other software
|
||||
# which invokes senlinclient today.
|
||||
# These methods form a temporary translation layer. This layer will be
|
||||
# useless when OpenStackSDK has adopted all senlin resources.
|
||||
# useless when OpenStackSDK has been adopted all senlin resources.
|
||||
######################################################################
|
||||
|
||||
def get_profile_type(self, profile_type):
|
||||
return self.conn.cluster.get_profile_type(profile_type)
|
||||
return self.service.get_profile_type(profile_type)
|
||||
|
||||
def profiles(self, **query):
|
||||
return self.conn.cluster.profiles(**query)
|
||||
return self.service.profiles(**query)
|
||||
|
||||
def create_profile(self, **attrs):
|
||||
return self.conn.cluster.create_profile(**attrs)
|
||||
return self.service.create_profile(**attrs)
|
||||
|
||||
def get_profile(self, profile):
|
||||
return self.conn.cluster.get_profile(profile)
|
||||
return self.service.get_profile(profile)
|
||||
|
||||
def update_profile(self, profile, **attrs):
|
||||
return self.conn.cluster.update_profile(profile, **attrs)
|
||||
return self.service.update_profile(profile, **attrs)
|
||||
|
||||
def delete_profile(self, profile, ignore_missing=True):
|
||||
return self.conn.cluster.delete_profile(profile,
|
||||
ignore_missing=ignore_missing)
|
||||
return self.service.delete_profile(profile, ignore_missing)
|
||||
|
||||
def policy_types(self, **query):
|
||||
return self.conn.cluster.policy_types(**query)
|
||||
return self.service.policy_types(**query)
|
||||
|
||||
def get_policy_type(self, policy_type):
|
||||
return self.conn.cluster.get_policy_type(policy_type)
|
||||
return self.service.get_policy_type(policy_type)
|
||||
|
||||
def policies(self, **query):
|
||||
return self.conn.cluster.policies(**query)
|
||||
return self.service.policies(**query)
|
||||
|
||||
def create_policy(self, **attrs):
|
||||
return self.conn.cluster.create_policy(**attrs)
|
||||
return self.service.create_policy(**attrs)
|
||||
|
||||
def get_policy(self, policy):
|
||||
return self.conn.cluster.get_policy(policy)
|
||||
return self.service.get_policy(policy)
|
||||
|
||||
def update_policy(self, policy, **attrs):
|
||||
return self.conn.cluster.update_policy(policy, **attrs)
|
||||
return self.service.update_policy(policy, **attrs)
|
||||
|
||||
def delete_policy(self, policy, ignore_missing=True):
|
||||
return self.conn.cluster.delete_policy(policy,
|
||||
ignore_missing=ignore_missing)
|
||||
return self.service.delete_policy(policy, ignore_missing)
|
||||
|
||||
def clusters(self, **queries):
|
||||
return self.conn.cluster.clusters(**queries)
|
||||
return self.service.clusters(**queries)
|
||||
|
||||
def create_cluster(self, **attrs):
|
||||
return self.conn.cluster.create_cluster(**attrs)
|
||||
return self.service.create_cluster(**attrs)
|
||||
|
||||
def get_cluster(self, value):
|
||||
return self.conn.cluster.get_cluster(value)
|
||||
def get_cluster(self, cluster):
|
||||
return self.service.get_cluster(cluster)
|
||||
|
||||
def update_cluster(self, value, **attrs):
|
||||
return self.conn.cluster.update_cluster(value, **attrs)
|
||||
def update_cluster(self, cluster, **attrs):
|
||||
return self.service.update_cluster(cluster, **attrs)
|
||||
|
||||
def delete_cluster(self, value, ignore_missing=True):
|
||||
return self.conn.cluster.delete_cluster(value,
|
||||
ignore_missing=ignore_missing)
|
||||
def delete_cluster(self, cluster, ignore_missing=True):
|
||||
return self.service.delete_cluster(cluster, ignore_missing)
|
||||
|
||||
def cluster_add_nodes(self, cluster, nodes):
|
||||
return self.conn.cluster.cluster_add_nodes(cluster, nodes)
|
||||
return self.service.cluster_add_nodes(cluster, nodes)
|
||||
|
||||
def cluster_del_nodes(self, cluster, nodes):
|
||||
return self.conn.cluster.cluster_del_nodes(cluster, nodes)
|
||||
return self.service.cluster_del_nodes(cluster, nodes)
|
||||
|
||||
def cluster_resize(self, cluster, **params):
|
||||
return self.conn.cluster.cluster_resize(cluster, **params)
|
||||
return self.service.cluster_resize(cluster, **params)
|
||||
|
||||
def cluster_scale_out(self, cluster, count):
|
||||
return self.conn.cluster.cluster_scale_out(cluster, count)
|
||||
return self.service.cluster_scale_out(cluster, count)
|
||||
|
||||
def cluster_scale_in(self, cluster, count):
|
||||
return self.conn.cluster.cluster_scale_in(cluster, count)
|
||||
return self.service.cluster_scale_in(cluster, count)
|
||||
|
||||
def cluster_policies(self, value, **queries):
|
||||
return self.list(models.ClusterPolicy, path_args={'cluster_id': value},
|
||||
**queries)
|
||||
def cluster_policies(self, cluster, **queries):
|
||||
return self.service_policies(cluster, **queries)
|
||||
|
||||
def get_cluster_policy(self, value):
|
||||
return self.get(models.ClusterPolicy, value)
|
||||
def get_cluster_policy(self, policy, cluster):
|
||||
return self.conn.get_cluster_policy(policy, cluster)
|
||||
|
||||
def cluster_attach_policy(self, cluster, policy, **attrs):
|
||||
return self.conn.cluster.cluster_attach_policy(cluster, policy,
|
||||
**attrs)
|
||||
return self.service.cluster_attach_policy(cluster, policy, **attrs)
|
||||
|
||||
def cluster_detach_policy(self, cluster, policy):
|
||||
return self.conn.cluster.cluster_detach_policy(cluster, policy)
|
||||
return self.service.cluster_detach_policy(cluster, policy)
|
||||
|
||||
def cluster_update_policy(self, cluster, policy, **attrs):
|
||||
return self.conn.cluster.cluster_update_policy(cluster, policy,
|
||||
**attrs)
|
||||
return self.service.cluster_update_policy(cluster, policy, **attrs)
|
||||
|
||||
def cluster_enable_policy(self, cluster, policy):
|
||||
return self.conn.cluster.cluster_enable_policy(cluster, policy)
|
||||
return self.service.cluster_enable_policy(cluster, policy)
|
||||
|
||||
def cluster_disable_policy(self, cluster, policy):
|
||||
return self.conn.cluster.cluster_disable_policy(cluster, policy)
|
||||
return self.service.cluster_disable_policy(cluster, policy)
|
||||
|
||||
def nodes(self, **queries):
|
||||
return self.list(models.Node, **queries)
|
||||
return self.service.nodes(**queries)
|
||||
|
||||
def create_node(self, **attrs):
|
||||
return self.create(models.Node, attrs)
|
||||
return self.service.create_node(**attrs)
|
||||
|
||||
def get_node(self, value, show_details=False):
|
||||
return self.get_with_args(models.Node,
|
||||
dict(id=value, show_details=show_details))
|
||||
def get_node(self, node, show_details=False):
|
||||
return self.service.get_node(node)
|
||||
|
||||
def update_node(self, value, **attrs):
|
||||
attrs['id'] = value
|
||||
return self.update(models.Node, attrs)
|
||||
def update_node(self, node, **attrs):
|
||||
return self.service.update_node(node, **attrs)
|
||||
|
||||
def delete_node(self, value, ignore_missing=True):
|
||||
return self.delete(models.Node,
|
||||
dict(id=value, ignore_missing=ignore_missing))
|
||||
def delete_node(self, node, ignore_missing=True):
|
||||
return self.service.delete_node(node, ignore_missing)
|
||||
|
||||
def node_join(self, value, cluster):
|
||||
params = {
|
||||
'id': value,
|
||||
'action': 'join',
|
||||
'action_args': {
|
||||
'cluster_id': cluster,
|
||||
}
|
||||
}
|
||||
return self.action(models.Node, params)
|
||||
def node_join(self, node, cluster):
|
||||
return self.service.node_join(node, cluster)
|
||||
|
||||
def node_leave(self, value):
|
||||
params = {
|
||||
'id': value,
|
||||
'action': 'leave',
|
||||
}
|
||||
return self.action(models.Node, params)
|
||||
def node_leave(self, node):
|
||||
return self.service.node_leave(node)
|
||||
|
||||
def receivers(self, **queries):
|
||||
return self.list(models.Receiver, **queries)
|
||||
return self.service.receivers(**queries)
|
||||
|
||||
def create_receiver(self, **attrs):
|
||||
return self.create(models.Receiver, attrs)
|
||||
return self.service.create_receiver(**attrs)
|
||||
|
||||
def get_receiver(self, value):
|
||||
return self.get(models.Receiver, dict(id=value))
|
||||
def get_receiver(self, receiver):
|
||||
return self.service.get_receiver(receiver)
|
||||
|
||||
def delete_receiver(self, value, ignore_missing=True):
|
||||
return self.delete(models.Receiver,
|
||||
dict(id=value, ignore_missing=ignore_missing))
|
||||
def delete_receiver(self, receiver, ignore_missing=True):
|
||||
return self.service.delete_receiver(receiver, ignore_missing)
|
||||
|
||||
def events(self, **queries):
|
||||
return self.list(models.Event, **queries)
|
||||
return self.service.events(**queries)
|
||||
|
||||
def get_event(self, value):
|
||||
return self.get(models.Event, dict(id=value))
|
||||
def get_event(self, event):
|
||||
return self.service.get_event(event)
|
||||
|
||||
def actions(self, **queries):
|
||||
return self.list(models.Action, **queries)
|
||||
return self.service.actions(**queries)
|
||||
|
||||
def get_action(self, value):
|
||||
return self.get(models.Action, dict(id=value))
|
||||
|
||||
######################################################################
|
||||
# The operations below should go away when Senlin resources are all
|
||||
# adopted into OpenStack SDK.
|
||||
######################################################################
|
||||
|
||||
def session(self, cls_name):
|
||||
if cls_name is None:
|
||||
raise Exception("A cls name argument must be specified")
|
||||
|
||||
filtration = identity_service.IdentityService()
|
||||
return self.session.get(cls_name, service=filtration).text
|
||||
|
||||
def list(self, cls, path_args=None, **options):
|
||||
try:
|
||||
return cls.list(self.session, path_args=path_args, params=options)
|
||||
except Exception as ex:
|
||||
client_exc.parse_exception(ex)
|
||||
|
||||
def create(self, cls, params, extra_attrs=False):
|
||||
obj = cls.new(**params)
|
||||
try:
|
||||
return obj.create(self.session, extra_attrs=extra_attrs)
|
||||
except Exception as ex:
|
||||
client_exc.parse_exception(ex)
|
||||
|
||||
def get_with_args(self, cls, options=None):
|
||||
if options is None:
|
||||
options = {}
|
||||
try:
|
||||
obj = cls.new(**options)
|
||||
return obj.get_with_args(self.session, options)
|
||||
except Exception as ex:
|
||||
client_exc.parse_exception(ex)
|
||||
|
||||
def get(self, cls, options=None):
|
||||
if options is None:
|
||||
options = {}
|
||||
try:
|
||||
obj = cls.new(**options)
|
||||
return obj.get(self.session)
|
||||
except Exception as ex:
|
||||
client_exc.parse_exception(ex)
|
||||
|
||||
def find(self, cls, options):
|
||||
return cls.find(self.session, options)
|
||||
|
||||
def update(self, cls, options):
|
||||
obj = cls.new(**options)
|
||||
try:
|
||||
obj.update(self.session)
|
||||
except Exception as ex:
|
||||
client_exc.parse_exception(ex)
|
||||
|
||||
def delete(self, cls, options):
|
||||
obj = cls.new(**options)
|
||||
try:
|
||||
obj.delete(self.session)
|
||||
except Exception as ex:
|
||||
client_exc.parse_exception(ex)
|
||||
|
||||
def action(self, cls, options):
|
||||
def filter_args(method, params):
|
||||
expected_args = inspect.getargspec(method).args
|
||||
accepted_args = ([a for a in expected_args and params
|
||||
if a != 'self'])
|
||||
filtered_args = dict((d, params[d]) for d in accepted_args)
|
||||
return filtered_args
|
||||
|
||||
def invoke_method(target, method_name, params):
|
||||
action = getattr(target, method_name)
|
||||
filtered_args = filter_args(action, params)
|
||||
reply = action(**filtered_args)
|
||||
return reply
|
||||
|
||||
action = options.pop('action')
|
||||
if 'action_args' in options:
|
||||
args = options.pop('action_args')
|
||||
else:
|
||||
args = {}
|
||||
|
||||
args.update(session=self.session)
|
||||
obj = cls.new(**options)
|
||||
try:
|
||||
return invoke_method(obj, action, args)
|
||||
except Exception as ex:
|
||||
client_exc.parse_exception(ex)
|
||||
def get_action(self, action):
|
||||
return self.service.get_action(action)
|
||||
|
||||
@ -19,13 +19,13 @@ from senlinclient.common import utils
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def do_build_info(sc, args=None):
|
||||
def do_build_info(service, args=None):
|
||||
"""Retrieve build information.
|
||||
|
||||
:param sc: Instance of senlinclient.
|
||||
:param args: Additional command line arguments, if any.
|
||||
"""
|
||||
result = sc.conn.cluster.get_build_info()
|
||||
result = service.get_build_info()
|
||||
|
||||
formatters = {
|
||||
'api': utils.json_formatter,
|
||||
@ -37,13 +37,13 @@ def do_build_info(sc, args=None):
|
||||
# PROFILE TYPES
|
||||
|
||||
|
||||
def do_profile_type_list(sc, args=None):
|
||||
def do_profile_type_list(service, args=None):
|
||||
"""List the available profile types.
|
||||
|
||||
:param sc: Instance of senlinclient.
|
||||
:param args: Additional command line arguments, if any.
|
||||
"""
|
||||
types = sc.conn.cluster.profile_types()
|
||||
types = service.profile_types()
|
||||
utils.print_list(types, ['name'], sortby_index=0)
|
||||
|
||||
|
||||
@ -53,10 +53,10 @@ def do_profile_type_list(sc, args=None):
|
||||
choices=utils.supported_formats.keys(),
|
||||
help=_("The template output format, one of: %s.")
|
||||
% ', '.join(utils.supported_formats.keys()))
|
||||
def do_profile_type_show(sc, args):
|
||||
def do_profile_type_show(service, args):
|
||||
"""Get the details about a profile type."""
|
||||
try:
|
||||
res = sc.conn.cluster.get_profile_type(args.type_name)
|
||||
res = service.get_profile_type(args.type_name)
|
||||
except exc.HTTPNotFound:
|
||||
raise exc.CommandError(
|
||||
_('Profile Type %s not found.') % args.type_name)
|
||||
@ -78,7 +78,7 @@ def do_profile_type_show(sc, args):
|
||||
help=_('Only return profiles that appear after the given ID.'))
|
||||
@utils.arg('-F', '--full-id', default=False, action="store_true",
|
||||
help=_('Print full IDs in list.'))
|
||||
def do_profile_list(sc, args=None):
|
||||
def do_profile_list(service, args=None):
|
||||
"""List profiles that meet the criteria."""
|
||||
fields = ['id', 'name', 'type', 'created_at']
|
||||
queries = {
|
||||
@ -86,7 +86,7 @@ def do_profile_list(sc, args=None):
|
||||
'marker': args.marker,
|
||||
}
|
||||
|
||||
profiles = sc.conn.cluster.profiles(**queries)
|
||||
profiles = service.profiles(**queries)
|
||||
formatters = {}
|
||||
if not args.full_id:
|
||||
formatters = {
|
||||
@ -95,9 +95,9 @@ def do_profile_list(sc, args=None):
|
||||
utils.print_list(profiles, fields, formatters=formatters, sortby_index=1)
|
||||
|
||||
|
||||
def _show_profile(sc, profile_id):
|
||||
def _show_profile(service, profile_id):
|
||||
try:
|
||||
profile = sc.conn.cluster.get_profile(profile_id)
|
||||
profile = service.get_profile(profile_id)
|
||||
except exc.HTTPNotFound:
|
||||
raise exc.CommandError(_('Profile not found: %s') % profile_id)
|
||||
|
||||
@ -123,7 +123,7 @@ def _show_profile(sc, profile_id):
|
||||
action='append')
|
||||
@utils.arg('name', metavar='<PROFILE_NAME>',
|
||||
help=_('Name of the profile to create.'))
|
||||
def do_profile_create(sc, args):
|
||||
def do_profile_create(service, args):
|
||||
"""Create a profile."""
|
||||
spec = utils.get_spec_content(args.spec_file)
|
||||
type_name = spec.get('type', None)
|
||||
@ -147,15 +147,15 @@ def do_profile_create(sc, args):
|
||||
'metadata': utils.format_parameters(args.metadata),
|
||||
}
|
||||
|
||||
profile = sc.conn.cluster.create_profile(**params)
|
||||
_show_profile(sc, profile.id)
|
||||
profile = service.create_profile(**params)
|
||||
_show_profile(service, profile.id)
|
||||
|
||||
|
||||
@utils.arg('id', metavar='<PROFILE>',
|
||||
help=_('Name or ID of profile to show.'))
|
||||
def do_profile_show(sc, args):
|
||||
def do_profile_show(service, args):
|
||||
"""Show the profile details."""
|
||||
_show_profile(sc, args.id)
|
||||
_show_profile(service, args.id)
|
||||
|
||||
|
||||
@utils.arg('-n', '--name', metavar='<NAME>',
|
||||
@ -169,7 +169,7 @@ def do_profile_show(sc, args):
|
||||
action='append')
|
||||
@utils.arg('id', metavar='<PROFILE_ID>',
|
||||
help=_('Name or ID of the profile to update.'))
|
||||
def do_profile_update(sc, args):
|
||||
def do_profile_update(service, args):
|
||||
"""Update a profile."""
|
||||
params = {
|
||||
'name': args.name,
|
||||
@ -180,22 +180,22 @@ def do_profile_update(sc, args):
|
||||
|
||||
# Find the profile first, we need its id
|
||||
try:
|
||||
profile = sc.conn.cluster.get_profile(args.id)
|
||||
profile = service.get_profile(args.id)
|
||||
except exc.HTTPNotFound:
|
||||
raise exc.CommandError(_('Profile not found: %s') % args.id)
|
||||
sc.conn.cluster.update_profile(profile.id, **params)
|
||||
_show_profile(sc, profile.id)
|
||||
service.update_profile(profile.id, **params)
|
||||
_show_profile(service, profile.id)
|
||||
|
||||
|
||||
@utils.arg('id', metavar='<PROFILE>', nargs='+',
|
||||
help=_('Name or ID of profile(s) to delete.'))
|
||||
def do_profile_delete(sc, args):
|
||||
def do_profile_delete(service, args):
|
||||
"""Delete profile(s)."""
|
||||
failure_count = 0
|
||||
|
||||
for pid in args.id:
|
||||
try:
|
||||
sc.conn.cluster.delete_profile(pid)
|
||||
service.delete_profile(pid)
|
||||
except Exception as ex:
|
||||
failure_count += 1
|
||||
print(ex)
|
||||
@ -208,9 +208,9 @@ def do_profile_delete(sc, args):
|
||||
# POLICY TYPES
|
||||
|
||||
|
||||
def do_policy_type_list(sc, args):
|
||||
def do_policy_type_list(service, args):
|
||||
"""List the available policy types."""
|
||||
types = sc.conn.cluster.policy_types()
|
||||
types = service.policy_types()
|
||||
utils.print_list(types, ['name'], sortby_index=0)
|
||||
|
||||
|
||||
@ -220,10 +220,10 @@ def do_policy_type_list(sc, args):
|
||||
choices=utils.supported_formats.keys(),
|
||||
help=_("The template output format, one of: %s.")
|
||||
% ', '.join(utils.supported_formats.keys()))
|
||||
def do_policy_type_show(sc, args):
|
||||
def do_policy_type_show(service, args):
|
||||
"""Get the details about a policy type."""
|
||||
try:
|
||||
res = sc.conn.cluster.get_policy_type(args.type_name)
|
||||
res = service.get_policy_type(args.type_name)
|
||||
except exc.HTTPNotFound:
|
||||
raise exc.CommandError(
|
||||
_('Policy type %s not found.') % args.type_name)
|
||||
@ -244,7 +244,7 @@ def do_policy_type_show(sc, args):
|
||||
help=_('Only return policies that appear after the given ID.'))
|
||||
@utils.arg('-F', '--full-id', default=False, action="store_true",
|
||||
help=_('Print full IDs in list.'))
|
||||
def do_policy_list(sc, args=None):
|
||||
def do_policy_list(service, args=None):
|
||||
"""List policies that meet the criteria."""
|
||||
fields = ['id', 'name', 'type', 'level', 'cooldown', 'created_at']
|
||||
queries = {
|
||||
@ -252,7 +252,7 @@ def do_policy_list(sc, args=None):
|
||||
'marker': args.marker,
|
||||
}
|
||||
|
||||
policies = sc.conn.cluster.policies(**queries)
|
||||
policies = service.policies(**queries)
|
||||
formatters = {}
|
||||
if not args.full_id:
|
||||
formatters = {
|
||||
@ -261,9 +261,9 @@ def do_policy_list(sc, args=None):
|
||||
utils.print_list(policies, fields, formatters=formatters, sortby_index=1)
|
||||
|
||||
|
||||
def _show_policy(sc, policy_id):
|
||||
def _show_policy(service, policy_id):
|
||||
try:
|
||||
policy = sc.conn.cluster.get_policy(policy_id)
|
||||
policy = service.get_policy(policy_id)
|
||||
except exc.HTTPNotFound:
|
||||
raise exc.CommandError(_('Policy not found: %s') % policy_id)
|
||||
|
||||
@ -284,7 +284,7 @@ def _show_policy(sc, policy_id):
|
||||
'level. Default to 0.'))
|
||||
@utils.arg('name', metavar='<NAME>',
|
||||
help=_('Name of the policy to create.'))
|
||||
def do_policy_create(sc, args):
|
||||
def do_policy_create(service, args):
|
||||
"""Create a policy."""
|
||||
spec = utils.get_spec_content(args.spec_file)
|
||||
attrs = {
|
||||
@ -294,15 +294,15 @@ def do_policy_create(sc, args):
|
||||
'level': args.enforcement_level,
|
||||
}
|
||||
|
||||
policy = sc.conn.cluster.create_policy(**attrs)
|
||||
_show_policy(sc, policy.id)
|
||||
policy = service.create_policy(**attrs)
|
||||
_show_policy(service, policy.id)
|
||||
|
||||
|
||||
@utils.arg('id', metavar='<POLICY>',
|
||||
help=_('Name of the policy to be updated.'))
|
||||
def do_policy_show(sc, args):
|
||||
def do_policy_show(service, args):
|
||||
"""Show the policy details."""
|
||||
_show_policy(sc, policy_id=args.id)
|
||||
_show_policy(service, policy_id=args.id)
|
||||
|
||||
|
||||
@utils.arg('-c', '--cooldown', metavar='<SECONDS>',
|
||||
@ -315,7 +315,7 @@ def do_policy_show(sc, args):
|
||||
help=_('New name of the policy to be updated.'))
|
||||
@utils.arg('id', metavar='<POLICY>',
|
||||
help=_('Name of the policy to be updated.'))
|
||||
def do_policy_update(sc, args):
|
||||
def do_policy_update(service, args):
|
||||
"""Update a policy."""
|
||||
params = {
|
||||
'name': args.name,
|
||||
@ -323,22 +323,22 @@ def do_policy_update(sc, args):
|
||||
'level': args.enforcement_level,
|
||||
}
|
||||
|
||||
policy = sc.conn.cluster.get_policy(args.id)
|
||||
policy = service.get_policy(args.id)
|
||||
if policy is not None:
|
||||
params['id'] = policy.id
|
||||
sc.conn.cluster.update_policy(policy.id, params)
|
||||
_show_policy(sc, policy_id=policy.id)
|
||||
service.update_policy(policy.id, params)
|
||||
_show_policy(service, policy_id=policy.id)
|
||||
|
||||
|
||||
@utils.arg('id', metavar='<POLICY>', nargs='+',
|
||||
help=_('Name or ID of policy(s) to delete.'))
|
||||
def do_policy_delete(sc, args):
|
||||
def do_policy_delete(service, args):
|
||||
"""Delete policy(s)."""
|
||||
failure_count = 0
|
||||
|
||||
for pid in args.id:
|
||||
try:
|
||||
sc.conn.cluster.delete_policy(pid)
|
||||
service.delete_policy(pid)
|
||||
except exc.HTTPNotFound as ex:
|
||||
failure_count += 1
|
||||
print(ex)
|
||||
@ -373,7 +373,7 @@ def do_policy_delete(sc, args):
|
||||
'checking. Default is False.'))
|
||||
@utils.arg('-F', '--full-id', default=False, action="store_true",
|
||||
help=_('Print full IDs in list.'))
|
||||
def do_cluster_list(sc, args=None):
|
||||
def do_cluster_list(service, args=None):
|
||||
"""List the user's clusters."""
|
||||
fields = ['id', 'name', 'status', 'created_at', 'updated_at']
|
||||
sort_keys = ['name', 'status', 'created_at', 'updated_at']
|
||||
@ -403,7 +403,7 @@ def do_cluster_list(sc, args=None):
|
||||
else:
|
||||
sortby_index = 3
|
||||
|
||||
clusters = sc.conn.cluster.clusters(**queries)
|
||||
clusters = service.clusters(**queries)
|
||||
formatters = {}
|
||||
if not args.full_id:
|
||||
formatters = {
|
||||
@ -413,9 +413,9 @@ def do_cluster_list(sc, args=None):
|
||||
sortby_index=sortby_index)
|
||||
|
||||
|
||||
def _show_cluster(sc, cluster_id):
|
||||
def _show_cluster(service, cluster_id):
|
||||
try:
|
||||
cluster = sc.conn.cluster.get_cluster(cluster_id)
|
||||
cluster = service.get_cluster(cluster_id)
|
||||
except exc.HTTPNotFound:
|
||||
raise exc.CommandError(_('Cluster %s is not found') % cluster_id)
|
||||
|
||||
@ -446,7 +446,7 @@ def _show_cluster(sc, cluster_id):
|
||||
action='append')
|
||||
@utils.arg('name', metavar='<CLUSTER_NAME>',
|
||||
help=_('Name of the cluster to create.'))
|
||||
def do_cluster_create(sc, args):
|
||||
def do_cluster_create(service, args):
|
||||
"""Create the cluster."""
|
||||
if args.min_size and not args.desired_capacity:
|
||||
args.desired_capacity = args.min_size
|
||||
@ -461,19 +461,19 @@ def do_cluster_create(sc, args):
|
||||
'timeout': args.timeout
|
||||
}
|
||||
|
||||
cluster = sc.conn.cluster.create_cluster(**attrs)
|
||||
_show_cluster(sc, cluster.id)
|
||||
cluster = service.create_cluster(**attrs)
|
||||
_show_cluster(service, cluster.id)
|
||||
|
||||
|
||||
@utils.arg('id', metavar='<CLUSTER>', nargs='+',
|
||||
help=_('Name or ID of cluster(s) to delete.'))
|
||||
def do_cluster_delete(sc, args):
|
||||
def do_cluster_delete(service, args):
|
||||
"""Delete the cluster(s)."""
|
||||
failure_count = 0
|
||||
|
||||
for cid in args.id:
|
||||
try:
|
||||
sc.conn.cluster.delete_cluster(cid)
|
||||
service.delete_cluster(cid)
|
||||
except exc.HTTPNotFound as ex:
|
||||
failure_count += 1
|
||||
print(ex)
|
||||
@ -499,9 +499,9 @@ def do_cluster_delete(sc, args):
|
||||
help=_('New name for the cluster to update.'))
|
||||
@utils.arg('id', metavar='<CLUSTER>',
|
||||
help=_('Name or ID of cluster to be updated.'))
|
||||
def do_cluster_update(sc, args):
|
||||
def do_cluster_update(service, args):
|
||||
"""Update the cluster."""
|
||||
cluster = sc.conn.cluster.get_cluster(args.id)
|
||||
cluster = service.get_cluster(args.id)
|
||||
attrs = {
|
||||
'name': args.name,
|
||||
'profile_id': args.profile,
|
||||
@ -510,15 +510,15 @@ def do_cluster_update(sc, args):
|
||||
'timeout': args.timeout,
|
||||
}
|
||||
|
||||
sc.conn.cluster.update_cluster(cluster.id, **attrs)
|
||||
_show_cluster(sc, cluster.id)
|
||||
service.update_cluster(cluster.id, **attrs)
|
||||
_show_cluster(service, cluster.id)
|
||||
|
||||
|
||||
@utils.arg('id', metavar='<CLUSTER>',
|
||||
help=_('Name or ID of cluster to show.'))
|
||||
def do_cluster_show(sc, args):
|
||||
def do_cluster_show(service, args):
|
||||
"""Show details of the cluster."""
|
||||
_show_cluster(sc, args.id)
|
||||
_show_cluster(service, args.id)
|
||||
|
||||
|
||||
@utils.arg('-f', '--filters', metavar='<KEY1=VALUE1;KEY2=VALUE2...>',
|
||||
@ -534,7 +534,7 @@ def do_cluster_show(sc, args):
|
||||
help=_('Print full IDs in list.'))
|
||||
@utils.arg('id', metavar='<CLUSTER>',
|
||||
help=_('Name or ID of cluster to nodes from.'))
|
||||
def do_cluster_node_list(sc, args):
|
||||
def do_cluster_node_list(service, args):
|
||||
"""List nodes from cluster."""
|
||||
|
||||
queries = {
|
||||
@ -546,7 +546,7 @@ def do_cluster_node_list(sc, args):
|
||||
queries.update(utils.format_parameters(args.filters))
|
||||
|
||||
try:
|
||||
nodes = sc.nodes(**queries)
|
||||
nodes = service.nodes(**queries)
|
||||
except exc.HTTPNotFound:
|
||||
msg = _('No node matching criteria is found')
|
||||
raise exc.CommandError(msg)
|
||||
@ -568,10 +568,10 @@ def do_cluster_node_list(sc, args):
|
||||
'with ","'))
|
||||
@utils.arg('id', metavar='<CLUSTER>',
|
||||
help=_('Name or ID of cluster to operate on.'))
|
||||
def do_cluster_node_add(sc, args):
|
||||
def do_cluster_node_add(service, args):
|
||||
"""Add specified nodes to cluster."""
|
||||
node_ids = args.nodes.split(',')
|
||||
resp = sc.conn.cluster.cluster_add_nodes(args.id, node_ids)
|
||||
resp = service.cluster_add_nodes(args.id, node_ids)
|
||||
print('Request accepted by action: %s' % resp['action'])
|
||||
|
||||
|
||||
@ -580,10 +580,10 @@ def do_cluster_node_add(sc, args):
|
||||
'with ",".'))
|
||||
@utils.arg('id', metavar='<CLUSTER>',
|
||||
help=_('Name or ID of cluster to operate on.'))
|
||||
def do_cluster_node_del(sc, args):
|
||||
def do_cluster_node_del(service, args):
|
||||
"""Delete specified nodes from cluster."""
|
||||
node_ids = args.nodes.split(',')
|
||||
resp = sc.conn.cluster.cluster_del_nodes(args.id, node_ids)
|
||||
resp = service.cluster_del_nodes(args.id, node_ids)
|
||||
print('Request accepted by action: %s' % resp['action'])
|
||||
|
||||
|
||||
@ -610,7 +610,7 @@ def do_cluster_node_del(sc, args):
|
||||
'no upper limit on cluster size.'))
|
||||
@utils.arg('id', metavar='<CLUSTER>',
|
||||
help=_('Name or ID of cluster to operate on.'))
|
||||
def do_cluster_resize(sc, args):
|
||||
def do_cluster_resize(service, args):
|
||||
"""Resize a cluster."""
|
||||
# validate parameters
|
||||
# NOTE: this will be much simpler if cliutils supports exclusive groups
|
||||
@ -677,7 +677,7 @@ def do_cluster_resize(sc, args):
|
||||
action_args['min_step'] = min_step
|
||||
action_args['strict'] = args.strict
|
||||
|
||||
resp = sc.conn.cluster.cluster_resize(args.id, **action_args)
|
||||
resp = service.cluster_resize(args.id, **action_args)
|
||||
print('Request accepted by action: %s' % resp['action'])
|
||||
|
||||
|
||||
@ -685,9 +685,9 @@ def do_cluster_resize(sc, args):
|
||||
help=_('Number of nodes to be added to the specified cluster.'))
|
||||
@utils.arg('id', metavar='<CLUSTER>',
|
||||
help=_('Name or ID of cluster to operate on.'))
|
||||
def do_cluster_scale_out(sc, args):
|
||||
def do_cluster_scale_out(service, args):
|
||||
"""Scale out a cluster by the specified number of nodes."""
|
||||
resp = sc.conn.cluster.cluster_scale_out(args.id, args.count)
|
||||
resp = service.cluster_scale_out(args.id, args.count)
|
||||
print('Request accepted by action %s' % resp['action'])
|
||||
|
||||
|
||||
@ -695,9 +695,9 @@ def do_cluster_scale_out(sc, args):
|
||||
help=_('Number of nodes to be deleted from the specified cluster.'))
|
||||
@utils.arg('id', metavar='<CLUSTER>',
|
||||
help=_('Name or ID of cluster to operate on.'))
|
||||
def do_cluster_scale_in(sc, args):
|
||||
def do_cluster_scale_in(service, args):
|
||||
"""Scale in a cluster by the specified number of nodes."""
|
||||
resp = sc.conn.cluster.cluster_scale_in(args.id, args.count)
|
||||
resp = service.cluster_scale_in(args.id, args.count)
|
||||
print('Request accepted by action %s' % resp['action'])
|
||||
|
||||
|
||||
@ -714,13 +714,13 @@ def do_cluster_scale_in(sc, args):
|
||||
help=_('Print full IDs in list.'))
|
||||
@utils.arg('id', metavar='<CLUSTER>',
|
||||
help=_('Name or ID of cluster to query on.'))
|
||||
def do_cluster_policy_list(sc, args):
|
||||
def do_cluster_policy_list(service, args):
|
||||
"""List policies from cluster."""
|
||||
fields = ['policy_id', 'policy', 'type', 'priority', 'level',
|
||||
'cooldown', 'enabled']
|
||||
sort_keys = ['priority', 'level', 'cooldown', 'enabled']
|
||||
|
||||
cluster = sc.get_cluster(args.id)
|
||||
cluster = service.get_cluster(args.id)
|
||||
queries = {
|
||||
'sort_keys': args.sort_keys,
|
||||
'sort_dir': args.sort_dir,
|
||||
@ -737,7 +737,7 @@ def do_cluster_policy_list(sc, args):
|
||||
else:
|
||||
sortby_index = 3
|
||||
|
||||
policies = sc.cluster_policies(cluster.id, **queries)
|
||||
policies = service.cluster_policies(cluster.id, **queries)
|
||||
formatters = {}
|
||||
if not args.full_id:
|
||||
formatters = {
|
||||
@ -752,13 +752,9 @@ def do_cluster_policy_list(sc, args):
|
||||
help=_('ID or name of the policy to query on.'))
|
||||
@utils.arg('id', metavar='<CLUSTER>',
|
||||
help=_('ID or name of the cluster to query on.'))
|
||||
def do_cluster_policy_show(sc, args):
|
||||
def do_cluster_policy_show(service, args):
|
||||
"""Show a specific policy that is bound to the specified cluster."""
|
||||
queries = {
|
||||
'cluster_id': args.id,
|
||||
'policy_id': args.policy
|
||||
}
|
||||
binding = sc.get_cluster_policy(queries)
|
||||
binding = service.get_cluster_policy(args.policy, args.id)
|
||||
utils.print_dict(binding.to_dict())
|
||||
|
||||
|
||||
@ -779,7 +775,7 @@ def do_cluster_policy_show(sc, args):
|
||||
'Default to enabled.'))
|
||||
@utils.arg('id', metavar='<NAME or ID>',
|
||||
help=_('Name or ID of cluster to operate on.'))
|
||||
def do_cluster_policy_attach(sc, args):
|
||||
def do_cluster_policy_attach(service, args):
|
||||
"""Attach policy to cluster."""
|
||||
kwargs = {
|
||||
'priority': args.priority,
|
||||
@ -788,8 +784,7 @@ def do_cluster_policy_attach(sc, args):
|
||||
'enabled': args.enabled,
|
||||
}
|
||||
|
||||
policy = args.policy
|
||||
resp = sc.conn.cluster.cluster_attach_policy(args.id, policy, **kwargs)
|
||||
resp = service.cluster_attach_policy(args.id, args.policy, **kwargs)
|
||||
print('Request accepted by action: %s' % resp['action'])
|
||||
|
||||
|
||||
@ -797,9 +792,9 @@ def do_cluster_policy_attach(sc, args):
|
||||
help=_('ID or name of policy to be detached.'))
|
||||
@utils.arg('id', metavar='<NAME or ID>',
|
||||
help=_('Name or ID of cluster to operate on.'))
|
||||
def do_cluster_policy_detach(sc, args):
|
||||
def do_cluster_policy_detach(service, args):
|
||||
"""Detach policy from cluster."""
|
||||
resp = sc.conn.cluster.cluster_detach_policy(args.id, args.policy)
|
||||
resp = service.cluster_detach_policy(args.id, args.policy)
|
||||
print('Request accepted by action %s' % resp['action'])
|
||||
|
||||
|
||||
@ -817,7 +812,7 @@ def do_cluster_policy_detach(sc, args):
|
||||
help=_('Whether the policy should be enabled.'))
|
||||
@utils.arg('id', metavar='<NAME or ID>',
|
||||
help=_('Name or ID of cluster to operate on.'))
|
||||
def do_cluster_policy_update(sc, args):
|
||||
def do_cluster_policy_update(service, args):
|
||||
"""Update a policy's properties on a cluster."""
|
||||
kwargs = {
|
||||
'policy_id': args.policy,
|
||||
@ -827,7 +822,7 @@ def do_cluster_policy_update(sc, args):
|
||||
'enabled': args.enabled,
|
||||
}
|
||||
|
||||
resp = sc.conn.cluster.cluster_update_policy(args.id, **kwargs)
|
||||
resp = service.cluster_update_policy(args.id, **kwargs)
|
||||
print('Request accepted by action: %s' % resp['action'])
|
||||
|
||||
|
||||
@ -835,9 +830,9 @@ def do_cluster_policy_update(sc, args):
|
||||
help=_('ID or name of policy to be enabled.'))
|
||||
@utils.arg('id', metavar='<NAME or ID>',
|
||||
help=_('Name or ID of cluster to operate on.'))
|
||||
def do_cluster_policy_enable(sc, args):
|
||||
def do_cluster_policy_enable(service, args):
|
||||
"""Enable a policy on a cluster."""
|
||||
resp = sc.conn.cluster.cluster_enable_policy(args.id, args.policy)
|
||||
resp = service.cluster_enable_policy(args.id, args.policy)
|
||||
print('Request accepted by action: %s' % resp['action'])
|
||||
|
||||
|
||||
@ -845,9 +840,9 @@ def do_cluster_policy_enable(sc, args):
|
||||
help=_('ID or name of policy to be disabled.'))
|
||||
@utils.arg('id', metavar='<NAME or ID>',
|
||||
help=_('Name or ID of cluster to operate on.'))
|
||||
def do_cluster_policy_disable(sc, args):
|
||||
def do_cluster_policy_disable(service, args):
|
||||
"""Disable a policy on a cluster."""
|
||||
resp = sc.conn.cluster.cluster_disable_policy(args.id, args.policy)
|
||||
resp = service.cluster_disable_policy(args.id, args.policy)
|
||||
print('Request accepted by action: %s' % resp['action'])
|
||||
|
||||
|
||||
@ -875,7 +870,7 @@ def do_cluster_policy_disable(sc, args):
|
||||
'checking. Default is False.'))
|
||||
@utils.arg('-F', '--full-id', default=False, action="store_true",
|
||||
help=_('Print full IDs in list.'))
|
||||
def do_node_list(sc, args):
|
||||
def do_node_list(service, args):
|
||||
"""Show list of nodes."""
|
||||
|
||||
fields = ['id', 'name', 'status', 'cluster_id', 'physical_id',
|
||||
@ -902,7 +897,7 @@ def do_node_list(sc, args):
|
||||
else:
|
||||
sortby_index = 6
|
||||
|
||||
nodes = sc.nodes(**queries)
|
||||
nodes = service.nodes(**queries)
|
||||
|
||||
if not args.full_id:
|
||||
formatters = {
|
||||
@ -917,10 +912,12 @@ def do_node_list(sc, args):
|
||||
sortby_index=sortby_index)
|
||||
|
||||
|
||||
def _show_node(sc, node_id, show_details=False):
|
||||
def _show_node(service, node_id, show_details=False):
|
||||
"""Show detailed info about the specified node."""
|
||||
|
||||
# TODO(Qiming): Re-enable show_details after SDK adopts related patch.
|
||||
try:
|
||||
node = sc.get_node(node_id, show_details)
|
||||
node = service.get_node(node_id)
|
||||
except exc.HTTPNotFound:
|
||||
msg = _('Node %s is not found') % node_id
|
||||
raise exc.CommandError(msg)
|
||||
@ -950,7 +947,7 @@ def _show_node(sc, node_id, show_details=False):
|
||||
action='append')
|
||||
@utils.arg('name', metavar='<NODE_NAME>',
|
||||
help=_('Name of the node to create.'))
|
||||
def do_node_create(sc, args):
|
||||
def do_node_create(service, args):
|
||||
"""Create the node."""
|
||||
attrs = {
|
||||
'name': args.name,
|
||||
@ -960,28 +957,28 @@ def do_node_create(sc, args):
|
||||
'metadata': utils.format_parameters(args.metadata),
|
||||
}
|
||||
|
||||
node = sc.create_node(**attrs)
|
||||
_show_node(sc, node.id)
|
||||
node = service.create_node(**attrs)
|
||||
_show_node(service, node.id)
|
||||
|
||||
|
||||
@utils.arg('-D', '--details', default=False, action="store_true",
|
||||
help=_('Include physical object details.'))
|
||||
@utils.arg('id', metavar='<NODE>',
|
||||
help=_('Name or ID of the node to show the details for.'))
|
||||
def do_node_show(sc, args):
|
||||
def do_node_show(service, args):
|
||||
"""Show detailed info about the specified node."""
|
||||
_show_node(sc, args.id, args.details)
|
||||
_show_node(service, args.id, args.details)
|
||||
|
||||
|
||||
@utils.arg('id', metavar='<NODE>', nargs='+',
|
||||
help=_('Name or ID of node(s) to delete.'))
|
||||
def do_node_delete(sc, args):
|
||||
def do_node_delete(service, args):
|
||||
"""Delete the node(s)."""
|
||||
failure_count = 0
|
||||
|
||||
for nid in args.id:
|
||||
try:
|
||||
sc.delete_node(nid)
|
||||
service.delete_node(nid, True)
|
||||
except exc.HTTPNotFound:
|
||||
failure_count += 1
|
||||
print('Node id "%s" not found' % nid)
|
||||
@ -1004,11 +1001,11 @@ def do_node_delete(sc, args):
|
||||
action='append')
|
||||
@utils.arg('id', metavar='<NODE>',
|
||||
help=_('Name or ID of node to update.'))
|
||||
def do_node_update(sc, args):
|
||||
def do_node_update(service, args):
|
||||
"""Update the node."""
|
||||
# Find the node first, we need its UUID
|
||||
try:
|
||||
node = sc.get_node(args.id)
|
||||
node = service.get_node(args.id)
|
||||
except exc.HTTPNotFound:
|
||||
raise exc.CommandError(_('Node not found: %s') % args.id)
|
||||
|
||||
@ -1019,28 +1016,28 @@ def do_node_update(sc, args):
|
||||
'metadata': utils.format_parameters(args.metadata),
|
||||
}
|
||||
|
||||
sc.update_node(args.id, **attrs)
|
||||
_show_node(sc, node.id)
|
||||
service.update_node(args.id, **attrs)
|
||||
_show_node(service, node.id)
|
||||
|
||||
|
||||
@utils.arg('-c', '--cluster', required=True,
|
||||
help=_('ID or name of cluster for node to join.'))
|
||||
@utils.arg('id', metavar='<NODE>',
|
||||
help=_('Name or ID of node to operate on.'))
|
||||
def do_node_join(sc, args):
|
||||
def do_node_join(service, args):
|
||||
"""Make node join the specified cluster."""
|
||||
resp = sc.node_join(args.id, args.cluster)
|
||||
resp = service.node_join(args.id, args.cluster)
|
||||
print('Request accepted by action: %s' % resp['action'])
|
||||
_show_node(sc, args.id)
|
||||
_show_node(service, args.id)
|
||||
|
||||
|
||||
@utils.arg('id', metavar='<NODE>',
|
||||
help=_('Name or ID of node to operate on.'))
|
||||
def do_node_leave(sc, args):
|
||||
def do_node_leave(service, args):
|
||||
"""Make node leave its current cluster."""
|
||||
resp = sc.node_leave(args.id)
|
||||
resp = service.node_leave(args.id)
|
||||
print('Request accepted by action: %s' % resp['action'])
|
||||
_show_node(sc, args.id)
|
||||
_show_node(service, args.id)
|
||||
|
||||
|
||||
# RECEIVERS
|
||||
@ -1065,7 +1062,7 @@ def do_node_leave(sc, args):
|
||||
'checking. Default is False.'))
|
||||
@utils.arg('-F', '--full-id', default=False, action="store_true",
|
||||
help=_('Print full IDs in list.'))
|
||||
def do_receiver_list(sc, args=None):
|
||||
def do_receiver_list(service, args=None):
|
||||
"""List receivers that meet the criteria."""
|
||||
fields = ['id', 'name', 'type', 'cluster_id', 'action', 'created_at']
|
||||
sort_keys = ['name', 'type', 'cluster_id', 'created_at']
|
||||
@ -1088,7 +1085,7 @@ def do_receiver_list(sc, args=None):
|
||||
else:
|
||||
sortby_index = 0
|
||||
|
||||
receivers = sc.receivers(**queries)
|
||||
receivers = service.receivers(**queries)
|
||||
formatters = {}
|
||||
if not args.full_id:
|
||||
formatters = {
|
||||
@ -1099,9 +1096,9 @@ def do_receiver_list(sc, args=None):
|
||||
sortby_index=sortby_index)
|
||||
|
||||
|
||||
def _show_receiver(sc, receiver_id):
|
||||
def _show_receiver(service, receiver_id):
|
||||
try:
|
||||
receiver = sc.get_receiver(receiver_id)
|
||||
receiver = service.get_receiver(receiver_id)
|
||||
except exc.HTTPNotFound:
|
||||
raise exc.CommandError(_('Receiver not found: %s') % receiver_id)
|
||||
|
||||
@ -1116,9 +1113,9 @@ def _show_receiver(sc, receiver_id):
|
||||
|
||||
@utils.arg('id', metavar='<RECEIVER>',
|
||||
help=_('Name or ID of the receiver to show.'))
|
||||
def do_receiver_show(sc, args):
|
||||
def do_receiver_show(service, args):
|
||||
"""Show the receiver details."""
|
||||
_show_receiver(sc, receiver_id=args.id)
|
||||
_show_receiver(service, receiver_id=args.id)
|
||||
|
||||
|
||||
@utils.arg('-t', '--type', metavar='<TYPE>', default='webhook',
|
||||
@ -1133,7 +1130,7 @@ def do_receiver_show(sc, args):
|
||||
action='append')
|
||||
@utils.arg('name', metavar='<NAME>',
|
||||
help=_('Name of the receiver to create.'))
|
||||
def do_receiver_create(sc, args):
|
||||
def do_receiver_create(service, args):
|
||||
"""Create a receiver."""
|
||||
|
||||
params = {
|
||||
@ -1144,19 +1141,19 @@ def do_receiver_create(sc, args):
|
||||
'params': utils.format_parameters(args.params)
|
||||
}
|
||||
|
||||
receiver = sc.create_receiver(**params)
|
||||
_show_receiver(sc, receiver.id)
|
||||
receiver = service.create_receiver(**params)
|
||||
_show_receiver(service, receiver.id)
|
||||
|
||||
|
||||
@utils.arg('id', metavar='<RECEIVER>', nargs='+',
|
||||
help=_('Name or ID of receiver(s) to delete.'))
|
||||
def do_receiver_delete(sc, args):
|
||||
def do_receiver_delete(service, args):
|
||||
"""Delete receiver(s)."""
|
||||
failure_count = 0
|
||||
|
||||
for wid in args.id:
|
||||
try:
|
||||
sc.delete_receiver(wid)
|
||||
service.delete_receiver(wid)
|
||||
except exc.HTTPNotFound as ex:
|
||||
failure_count += 1
|
||||
print(ex)
|
||||
@ -1188,7 +1185,7 @@ def do_receiver_delete(sc, args):
|
||||
'for an admin privilege.'))
|
||||
@utils.arg('-F', '--full-id', default=False, action="store_true",
|
||||
help=_('Print full IDs in list.'))
|
||||
def do_event_list(sc, args):
|
||||
def do_event_list(service, args):
|
||||
"""List events."""
|
||||
|
||||
fields = ['id', 'timestamp', 'obj_type', 'obj_id', 'obj_name', 'action',
|
||||
@ -1219,17 +1216,17 @@ def do_event_list(sc, args):
|
||||
formatters['id'] = lambda x: x.id[:8]
|
||||
formatters['obj_id'] = lambda x: x.obj_id[:8] if x.obj_id else ''
|
||||
|
||||
events = sc.events(**queries)
|
||||
events = service.events(**queries)
|
||||
utils.print_list(events, fields, formatters=formatters,
|
||||
sortby_index=sortby_index)
|
||||
|
||||
|
||||
@utils.arg('id', metavar='<EVENT>',
|
||||
help=_('ID of event to display details for.'))
|
||||
def do_event_show(sc, args):
|
||||
def do_event_show(service, args):
|
||||
"""Describe the event."""
|
||||
try:
|
||||
event = sc.get_event(args.id)
|
||||
event = service.get_event(args.id)
|
||||
except exc.HTTPNotFound as ex:
|
||||
raise exc.CommandError(str(ex))
|
||||
|
||||
@ -1254,7 +1251,7 @@ def do_event_show(sc, args):
|
||||
help=_('Only return actions that appear after the given node ID.'))
|
||||
@utils.arg('-F', '--full-id', default=False, action="store_true",
|
||||
help=_('Print full IDs in list.'))
|
||||
def do_action_list(sc, args):
|
||||
def do_action_list(service, args):
|
||||
"""List actions."""
|
||||
|
||||
fields = ['id', 'name', 'action', 'status', 'target', 'depends_on',
|
||||
@ -1279,7 +1276,7 @@ def do_action_list(sc, args):
|
||||
else:
|
||||
sortby_index = 0
|
||||
|
||||
actions = sc.actions(**queries)
|
||||
actions = service.actions(**queries)
|
||||
|
||||
formatters = {}
|
||||
if args.full_id:
|
||||
@ -1302,10 +1299,10 @@ def do_action_list(sc, args):
|
||||
|
||||
@utils.arg('id', metavar='<ACTION>',
|
||||
help=_('Name or ID of the action to show the details for.'))
|
||||
def do_action_show(sc, args):
|
||||
def do_action_show(service, args):
|
||||
"""Show detailed info about the specified action."""
|
||||
try:
|
||||
action = sc.get_action(args.id)
|
||||
action = service.get_action(args.id)
|
||||
except exc.HTTPNotFound:
|
||||
msg = _('Action %(id)s is not found') % {'id': args.id}
|
||||
raise exc.CommandError(msg)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user