diff --git a/senlinclient/shell.py b/senlinclient/shell.py index 08e802f5..534257da 100644 --- a/senlinclient/shell.py +++ b/senlinclient/shell.py @@ -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() diff --git a/senlinclient/tests/unit/v1/test_shell.py b/senlinclient/tests/unit/v1/test_shell.py index f16b35ea..38c502de 100644 --- a/senlinclient/tests/unit/v1/test_shell.py +++ b/senlinclient/tests/unit/v1/test_shell.py @@ -50,65 +50,64 @@ class ShellTest(testtools.TestCase): @mock.patch.object(utils, 'print_dict') def test_do_build_info(self, mock_print): - client = mock.Mock() + service = mock.Mock() result = mock.Mock() - client.conn.cluster.get_build_info.return_value = result - sh.do_build_info(client) + service.get_build_info.return_value = result + sh.do_build_info(service) formatters = { 'api': utils.json_formatter, 'engine': utils.json_formatter, } mock_print.assert_called_once_with(result, formatters=formatters) - self.assertTrue(client.conn.cluster.get_build_info.called) + self.assertTrue(service.get_build_info.called) @mock.patch.object(utils, 'print_list') def test_do_profile_type_list(self, mock_print): - client = mock.Mock() + service = mock.Mock() types = mock.Mock() - client.conn.cluster.profile_types.return_value = types - sh.do_profile_type_list(client) + service.profile_types.return_value = types + sh.do_profile_type_list(service) mock_print.assert_called_once_with(types, ['name'], sortby_index=0) - self.assertTrue(client.conn.cluster.profile_types.called) + self.assertTrue(service.profile_types.called) @mock.patch.object(utils, 'format_output') def test_do_profile_type_show(self, mock_format): - client = mock.Mock() + service = mock.Mock() fake_pt = mock.Mock() fake_pt.to_dict.return_value = {'foo': 'bar'} - client.conn.cluster.get_profile_type = mock.Mock(return_value=fake_pt) + service.get_profile_type = mock.Mock(return_value=fake_pt) args_dict = { 'format': 'json', 'type_name': 'os.nova.server' } args = self._make_args(args_dict) - sh.do_profile_type_show(client, args) + sh.do_profile_type_show(service, args) mock_format.assert_called_with({'foo': 'bar'}, format=args.format) - client.conn.cluster.get_profile_type.assert_called_with( - 'os.nova.server') + service.get_profile_type.assert_called_with('os.nova.server') args.format = None - sh.do_profile_type_show(client, args) + sh.do_profile_type_show(service, args) mock_format.assert_called_with({'foo': 'bar'}) def test_do_profile_type_show_type_not_found(self): - client = mock.Mock() + service = mock.Mock() args = { 'type_name': 'wrong_type', 'format': 'json' } args = self._make_args(args) ex = exc.HTTPNotFound - client.conn.cluster.get_profile_type = mock.Mock(side_effect=ex) + service.get_profile_type = mock.Mock(side_effect=ex) ex = self.assertRaises(exc.CommandError, sh.do_profile_type_show, - client, args) + service, args) self.assertEqual(_('Profile Type wrong_type not found.'), six.text_type(ex)) @mock.patch.object(utils, 'print_list') def test_do_profile_list(self, mock_print): - client = mock.Mock() + service = mock.Mock() profiles = mock.Mock() - client.conn.cluster.profiles.return_value = profiles + service.profiles.return_value = profiles fields = ['id', 'name', 'type', 'created_at'] args = { 'limit': 20, @@ -118,18 +117,18 @@ class ShellTest(testtools.TestCase): formatters = {} args = self._make_args(args) args.full_id = True - sh.do_profile_list(client, args) - client.conn.cluster.profiles.assert_called_once_with(**queries) + sh.do_profile_list(service, args) + service.profiles.assert_called_once_with(**queries) mock_print.assert_called_with(profiles, fields, formatters=formatters, sortby_index=1) @mock.patch.object(utils, 'nested_dict_formatter') @mock.patch.object(utils, 'print_dict') def test_show_profile(self, mock_print, mock_dict): - client = mock.Mock() + service = mock.Mock() profile = mock.Mock() profile_id = mock.Mock() - client.conn.cluster.get_profile.return_value = profile + service.get_profile.return_value = profile pro_to_dict = mock.Mock() profile.to_dict.return_value = pro_to_dict json_formatter = mock.Mock() @@ -140,22 +139,22 @@ class ShellTest(testtools.TestCase): 'metadata': json_formatter, 'spec': dict_formatter } - sh._show_profile(client, profile_id) - client.conn.cluster.get_profile.assert_called_once_with(profile_id) + sh._show_profile(service, profile_id) + service.get_profile.assert_called_once_with(profile_id) mock_dict.assert_called_once_with(['type', 'version', 'properties'], ['property', 'value']) mock_print.assert_called_once_with(pro_to_dict, formatters=formatters) def test_show_profile_not_found(self): - client = mock.Mock() + service = mock.Mock() ex = exc.HTTPNotFound - client.conn.cluster.get_profile.side_effect = ex + service.get_profile.side_effect = ex profile_id = 'wrong_id' ex = self.assertRaises(exc.CommandError, sh._show_profile, - client, profile_id) + service, profile_id) self.assertEqual(_('Profile not found: wrong_id'), six.text_type(ex)) - client.conn.cluster.get_profile.assert_called_once_with(profile_id) + service.get_profile.assert_called_once_with(profile_id) @mock.patch.object(sh, '_show_profile') @mock.patch.object(utils, 'format_parameters') @@ -176,23 +175,25 @@ class ShellTest(testtools.TestCase): 'permission': 'ok', 'metadata': {'user': 'demo'}, } - client = mock.Mock() + service = mock.Mock() profile = mock.Mock() profile_id = mock.Mock() profile.id = profile_id - client.conn.cluster.create_profile.return_value = profile - sh.do_profile_create(client, args) + service.create_profile.return_value = profile + + sh.do_profile_create(service, args) + mock_get.assert_called_once_with(args.spec_file) mock_proc.assert_called_once_with(self.profile_spec['properties']) mock_format.assert_called_once_with(args.metadata) - client.conn.cluster.create_profile.assert_called_once_with(**params) - mock_show.assert_called_once_with(client, profile_id) + service.create_profile.assert_called_once_with(**params) + mock_show.assert_called_once_with(service, profile_id) # Miss 'type' key in spec file del spec['type'] ex = self.assertRaises(exc.CommandError, sh.do_profile_create, - client, args) + service, args) self.assertEqual(_("Missing 'type' key in spec file."), six.text_type(ex)) # Miss 'version' key in spec file @@ -200,7 +201,7 @@ class ShellTest(testtools.TestCase): del spec['version'] ex = self.assertRaises(exc.CommandError, sh.do_profile_create, - client, args) + service, args) self.assertEqual(_("Missing 'version' key in spec file."), six.text_type(ex)) # Miss 'properties' key in spec file @@ -208,17 +209,17 @@ class ShellTest(testtools.TestCase): del spec['properties'] ex = self.assertRaises(exc.CommandError, sh.do_profile_create, - client, args) + service, args) self.assertEqual(_("Missing 'properties' key in spec file."), six.text_type(ex)) @mock.patch.object(sh, '_show_profile') def test_do_profile_show(self, mock_show): - client = mock.Mock() + service = mock.Mock() args = {'id': 'profile_id'} args = self._make_args(args) - sh.do_profile_show(client, args) - mock_show.assert_called_once_with(client, args.id) + sh.do_profile_show(service, args) + mock_show.assert_called_once_with(service, args.id) @mock.patch.object(sh, '_show_profile') @mock.patch.object(utils, 'format_parameters') @@ -226,72 +227,73 @@ class ShellTest(testtools.TestCase): args = copy.deepcopy(self.profile_args) args = self._make_args(args) mock_format.return_value = {'user': 'demo'} - client = mock.Mock() + service = mock.Mock() profile = mock.Mock() profile_id = mock.Mock() profile.id = profile_id args.id = 'FAKE_ID' - client.conn.cluster.get_profile.return_value = profile - sh.do_profile_update(client, args) + service.get_profile.return_value = profile + + sh.do_profile_update(service, args) + mock_format.assert_called_once_with(args.metadata) - client.conn.cluster.get_profile.assert_called_once_with('FAKE_ID') + service.get_profile.assert_called_once_with('FAKE_ID') params = { 'name': 'stack_spec', 'permission': 'ok', 'metadata': {'user': 'demo'}, } - client.conn.cluster.update_profile.assert_called_once_with( - profile_id, **params) - mock_show.assert_called_once_with(client, profile_id) + service.update_profile.assert_called_once_with(profile_id, **params) + mock_show.assert_called_once_with(service, profile_id) @mock.patch.object(utils, 'format_parameters') def test_do_profile_update_not_found(self, mock_format): - client = mock.Mock() + service = mock.Mock() args = copy.deepcopy(self.profile_args) args = self._make_args(args) args.id = 'FAKE_ID' ex = exc.HTTPNotFound - client.conn.cluster.get_profile.side_effect = ex + service.get_profile.side_effect = ex ex = self.assertRaises(exc.CommandError, sh.do_profile_update, - client, args) + service, args) self.assertEqual(_('Profile not found: FAKE_ID'), six.text_type(ex)) mock_format.assert_called_once_with(args.metadata) def test_do_profile_delete(self): - client = mock.Mock() + service = mock.Mock() args = {'id': ['profile_id']} args = self._make_args(args) - sh.do_profile_delete(client, args) - client.conn.cluster.delete_profile.assert_called_with('profile_id') + sh.do_profile_delete(service, args) + service.delete_profile.assert_called_with('profile_id') def test_do_profile_delete_fail(self): - client = mock.Mock() + service = mock.Mock() args = {'id': ['profile1', 'profile2']} args = self._make_args(args) - sh.do_profile_delete(client, args) + sh.do_profile_delete(service, args) ex = Exception() - client.conn.cluster.delete_profile.side_effect = ex + service.delete_profile.side_effect = ex ex = self.assertRaises(exc.CommandError, sh.do_profile_delete, - client, args) + service, args) self.assertEqual(_('Failed to delete some of the specified ' 'profile(s).'), six.text_type(ex)) - client.conn.cluster.delete_profile.assert_called_with('profile2') + service.delete_profile.assert_called_with('profile2') @mock.patch.object(utils, 'print_list') def test_do_policy_type_list(self, mock_print): - client = mock.Mock() + service = mock.Mock() args = mock.Mock() types = mock.Mock() - client.conn.cluster.policy_types.return_value = types - sh.do_policy_type_list(client, args) + service.policy_types.return_value = types + sh.do_policy_type_list(service, args) mock_print.assert_called_once_with(types, ['name'], sortby_index=0) @mock.patch.object(utils, 'format_output') def test_do_policy_type_show(self, mock_format): - client = mock.Mock() + service = mock.Mock() args = { 'type_name': 'senlin.policy.deletion', 'format': 'yaml' @@ -300,8 +302,8 @@ class ShellTest(testtools.TestCase): res = mock.Mock() pt = mock.Mock() res.to_dict.return_value = pt - client.conn.cluster.get_policy_type.return_value = res - sh.do_policy_type_show(client, args) + service.get_policy_type.return_value = res + sh.do_policy_type_show(service, args) mock_format.assert_called_with(pt, format=args.format) # no format attribute @@ -310,24 +312,24 @@ class ShellTest(testtools.TestCase): 'format': None } args = self._make_args(args) - client.conn.cluster.get_policy_type.return_value = res - sh.do_policy_type_show(client, args) + service.get_policy_type.return_value = res + sh.do_policy_type_show(service, args) mock_format.assert_called_with(pt) def test_do_policy_type_show_not_found(self): - client = mock.Mock() - args = {'type_name': 'wrong_policy_type'} + service = mock.Mock() + args = {'type_name': 'BAD'} args = self._make_args(args) - ex = exc.HTTPNotFound - client.conn.cluster.get_policy_type.side_effect = ex + + service.get_policy_type.side_effect = exc.HTTPNotFound ex = self.assertRaises(exc.CommandError, - sh.do_policy_type_show, client, args) - msg = _('Policy type wrong_policy_type not found.') + sh.do_policy_type_show, service, args) + msg = _('Policy type BAD not found.') self.assertEqual(msg, six.text_type(ex)) @mock.patch.object(utils, 'print_list') def test_do_receiver_list(self, mock_print): - client = mock.Mock() + service = mock.Mock() params = { 'limit': 10, 'marker': 'fake_id', @@ -346,71 +348,71 @@ class ShellTest(testtools.TestCase): r1.id = '01234567-abcd-efgh' r1.cluster_id = 'abcdefgh-abcd-efgh' receivers = [r1] - client.receivers.return_value = receivers + service.receivers.return_value = receivers formatters = { 'id': mock.ANY, 'cluster_id': mock.ANY } - sh.do_receiver_list(client, args) + sh.do_receiver_list(service, args) mock_print.assert_called_with(receivers, fields, formatters=formatters, sortby_index=None) # full_id is requested args.full_id = True - sh.do_receiver_list(client, args) + sh.do_receiver_list(service, args) mock_print.assert_called_with(receivers, fields, formatters={}, sortby_index=None) # default sorting args.sort_keys = None - sh.do_receiver_list(client, args) + sh.do_receiver_list(service, args) mock_print.assert_called_with(receivers, fields, formatters={}, sortby_index=0) @mock.patch.object(utils, 'print_dict') def test_show_receiver(self, mock_print): - client = mock.Mock() + service = mock.Mock() receiver = mock.Mock() receiver_id = '01234567-abcd-abcd-abcdef' receiver.id = receiver_id - client.get_receiver.return_value = receiver + service.get_receiver.return_value = receiver receiver_dict = mock.Mock() receiver.to_dict.return_value = receiver_dict - sh._show_receiver(client, receiver_id) + sh._show_receiver(service, receiver_id) formatters = { 'actor': utils.json_formatter, 'params': utils.json_formatter, 'channel': utils.json_formatter, } - client.get_receiver.assert_called_once_with(receiver_id) + service.get_receiver.assert_called_once_with(receiver_id) mock_print.assert_called_once_with(receiver_dict, formatters=formatters) def test_show_receiver_not_found(self): - client = mock.Mock() + service = mock.Mock() receiver = mock.Mock() receiver_id = 'wrong_id' receiver.id = receiver_id - ex = exc.HTTPNotFound - client.get_receiver.side_effect = ex + + service.get_receiver.side_effect = exc.HTTPNotFound ex = self.assertRaises(exc.CommandError, - sh._show_receiver, client, receiver_id) + sh._show_receiver, service, receiver_id) self.assertEqual(_('Receiver not found: wrong_id'), six.text_type(ex)) @mock.patch.object(sh, '_show_receiver') def test_do_receiver_show(self, mock_show): - client = mock.Mock() + service = mock.Mock() args = {'id': 'receiver_id'} args = self._make_args(args) - sh.do_receiver_show(client, args) - mock_show.assert_called_once_with(client, + sh.do_receiver_show(service, args) + mock_show.assert_called_once_with(service, receiver_id='receiver_id') @mock.patch.object(sh, '_show_receiver') def test_do_receiver_create(self, mock_show): - client = mock.Mock() + service = mock.Mock() args = { 'name': 'receiver1', 'type': 'webhook', @@ -428,33 +430,33 @@ class ShellTest(testtools.TestCase): } receiver = mock.Mock() receiver.id = 'FAKE_ID' - client.create_receiver.return_value = receiver - sh.do_receiver_create(client, args) - client.create_receiver.assert_called_once_with(**params) - mock_show.assert_called_once_with(client, 'FAKE_ID') + service.create_receiver.return_value = receiver + sh.do_receiver_create(service, args) + service.create_receiver.assert_called_once_with(**params) + mock_show.assert_called_once_with(service, 'FAKE_ID') def test_do_receiver_delete(self): - client = mock.Mock() - args = {'id': ['receiver_id']} + service = mock.Mock() + args = {'id': ['FAKE']} args = self._make_args(args) - client.delete_receiver = mock.Mock() - sh.do_receiver_delete(client, args) - client.delete_receiver.assert_called_once_with('receiver_id') + service.delete_receiver = mock.Mock() + sh.do_receiver_delete(service, args) + service.delete_receiver.assert_called_once_with('FAKE') def test_do_receiver_delete_not_found(self): - client = mock.Mock() + service = mock.Mock() args = {'id': ['receiver_id']} args = self._make_args(args) - ex = exc.HTTPNotFound - client.delete_receiver.side_effect = ex + + service.delete_receiver.side_effect = exc.HTTPNotFound ex = self.assertRaises(exc.CommandError, - sh.do_receiver_delete, client, args) + sh.do_receiver_delete, service, args) msg = _('Failed to delete some of the specified receiver(s).') self.assertEqual(msg, six.text_type(ex)) @mock.patch.object(utils, 'print_list') def test_do_policy_list(self, mock_print): - client = mock.Mock() + service = mock.Mock() fields = ['id', 'name', 'type', 'level', 'cooldown', 'created_at'] args = { 'limit': 20, @@ -468,16 +470,16 @@ class ShellTest(testtools.TestCase): 'fake_id', } policies = mock.Mock() - client.conn.cluster.policies.return_value = policies + service.policies.return_value = policies formatters = {} - sh.do_policy_list(client, args) - client.conn.cluster.policies.assert_called_once_with(**queries) + sh.do_policy_list(service, args) + service.policies.assert_called_once_with(**queries) mock_print.assert_called_once_with( policies, fields, formatters=formatters, sortby_index=1) @mock.patch.object(utils, 'print_dict') def test_show_policy(self, mock_print): - client = mock.Mock() + service = mock.Mock() formatters = { 'metadata': utils.json_formatter, 'spec': utils.json_formatter, @@ -485,26 +487,26 @@ class ShellTest(testtools.TestCase): policy_id = 'fake_policy_id' policy = mock.Mock() policy.id = policy_id - client.conn.cluster.get_policy.return_value = policy + service.get_policy.return_value = policy policy_dict = mock.Mock() policy.to_dict.return_value = policy_dict - sh._show_policy(client, policy_id) + sh._show_policy(service, policy_id) mock_print.assert_called_once_with(policy_dict, formatters=formatters) # policy not found ex = exc.HTTPNotFound - client.conn.cluster.get_policy.side_effect = ex + service.get_policy.side_effect = ex ex = self.assertRaises(exc.CommandError, sh._show_policy, - client, policy_id) + service, policy_id) msg = _('Policy not found: fake_policy_id') self.assertEqual(msg, six.text_type(ex)) @mock.patch.object(sh, '_show_policy') @mock.patch.object(utils, 'get_spec_content') def test_do_policy_create(self, mock_get, mock_show): - client = mock.Mock() + service = mock.Mock() spec = mock.Mock() mock_get.return_value = spec args = { @@ -522,23 +524,23 @@ class ShellTest(testtools.TestCase): } policy = mock.Mock() policy.id = 'policy_id' - client.conn.cluster.create_policy.return_value = policy - sh.do_policy_create(client, args) + service.create_policy.return_value = policy + sh.do_policy_create(service, args) mock_get.assert_called_once_with(args.spec_file) - client.conn.cluster.create_policy.assert_called_once_with(**attrs) - mock_show.assert_called_once_with(client, policy.id) + service.create_policy.assert_called_once_with(**attrs) + mock_show.assert_called_once_with(service, policy.id) @mock.patch.object(sh, '_show_policy') def test_do_policy_show(self, mock_show): - client = mock.Mock() + service = mock.Mock() args = {'id': 'policy_id'} args = self._make_args(args) - sh.do_policy_show(client, args) - mock_show.assert_called_once_with(client, policy_id='policy_id') + sh.do_policy_show(service, args) + mock_show.assert_called_once_with(service, policy_id='policy_id') @mock.patch.object(sh, '_show_policy') def test_do_policy_update(self, mock_show): - client = mock.Mock() + service = mock.Mock() args = { 'name': 'deletion_policy', 'cooldown': 10, @@ -553,36 +555,36 @@ class ShellTest(testtools.TestCase): 'id': 'policy_id' } policy = mock.Mock() - client.conn.cluster.get_policy.return_value = policy + service.get_policy.return_value = policy policy.id = 'policy_id' - sh.do_policy_update(client, args) - client.conn.cluster.get_policy.assert_called_once_with('policy_id') - client.conn.cluster.update_policy.assert_called_once_with( + sh.do_policy_update(service, args) + service.get_policy.assert_called_once_with('policy_id') + service.update_policy.assert_called_once_with( 'policy_id', params) - mock_show(client, policy_id=policy.id) + mock_show(service, policy_id=policy.id) def test_do_policy_delete(self): - client = mock.Mock() + service = mock.Mock() args = {'id': ['policy_id']} args = self._make_args(args) - client.conn.cluster.delete_policy = mock.Mock() - sh.do_policy_delete(client, args) - client.conn.cluster.delete_policy.assert_called_once_with('policy_id') + service.delete_policy = mock.Mock() + sh.do_policy_delete(service, args) + service.delete_policy.assert_called_once_with('policy_id') def test_do_policy_delete_not_found(self): - client = mock.Mock() + service = mock.Mock() args = {'id': ['policy_id']} args = self._make_args(args) - ex = exc.HTTPNotFound - client.conn.cluster.delete_policy.side_effect = ex + + service.delete_policy.side_effect = exc.HTTPNotFound ex = self.assertRaises(exc.CommandError, - sh.do_policy_delete, client, args) + sh.do_policy_delete, service, args) msg = _('Failed to delete some of the specified policy(s).') self.assertEqual(msg, six.text_type(ex)) @mock.patch.object(utils, 'print_list') def test_do_cluster_list(self, mock_print): - client = mock.Mock() + service = mock.Mock() fields = ['id', 'name', 'status', 'created_at', 'updated_at', 'parent'] args = { 'limit': 20, @@ -598,11 +600,11 @@ class ShellTest(testtools.TestCase): queries['status'] = 'ACTIVE' args = self._make_args(args) clusters = mock.Mock() - client.conn.cluster.clusters.return_value = clusters + service.clusters.return_value = clusters args.full_id = True formatters = {} - sh.do_cluster_list(client, args) - client.conn.cluster.clusters.assert_called_once_with(**queries) + sh.do_cluster_list(service, args) + service.clusters.assert_called_once_with(**queries) mock_print.assert_called_once_with(clusters, fields, formatters=formatters, sortby_index=None) @@ -610,28 +612,28 @@ class ShellTest(testtools.TestCase): # invalid sort key args.sort_keys = 'id' ex = exc.CommandError - ex = self.assertRaises(ex, sh.do_cluster_list, client, args) + ex = self.assertRaises(ex, sh.do_cluster_list, service, args) self.assertEqual(_('Invalid sorting key: id'), six.text_type(ex)) @mock.patch.object(utils, 'print_dict') def test_show_cluster(self, mock_print): - client = mock.Mock() + service = mock.Mock() cluster_id = 'cluster_id' cluster = mock.Mock() cluster.id = cluster_id - client.conn.cluster.get_cluster.return_value = cluster + service.get_cluster.return_value = cluster formatters = { 'metadata': utils.json_formatter, 'nodes': utils.list_formatter, } cluster_dict = mock.Mock() cluster.to_dict.return_value = cluster_dict - sh._show_cluster(client, cluster_id) + sh._show_cluster(service, cluster_id) mock_print.assert_called_once_with(cluster_dict, formatters=formatters) @mock.patch.object(sh, '_show_cluster') def test_do_cluster_create(self, mock_show): - client = mock.Mock() + service = mock.Mock() args = { 'name': 'CLUSTER1', 'profile': 'profile1', @@ -648,34 +650,34 @@ class ShellTest(testtools.TestCase): del attrs['profile'] attrs['metadata'] = {'user': 'demo'} cluster = mock.Mock() - client.conn.cluster.create_cluster.return_value = cluster + service.create_cluster.return_value = cluster cluster.id = 'cluster_id' - sh.do_cluster_create(client, args) - client.conn.cluster.create_cluster.assert_called_once_with(**attrs) - mock_show.assert_called_once_with(client, 'cluster_id') + sh.do_cluster_create(service, args) + service.create_cluster.assert_called_once_with(**attrs) + mock_show.assert_called_once_with(service, 'cluster_id') def test_do_cluster_delete(self): - client = mock.Mock() + service = mock.Mock() args = {'id': ['CID']} args = self._make_args(args) - client.conn.cluster.delete_cluster = mock.Mock() - sh.do_cluster_delete(client, args) - client.conn.cluster.delete_cluster.assert_called_once_with('CID') + service.delete_cluster = mock.Mock() + sh.do_cluster_delete(service, args) + service.delete_cluster.assert_called_once_with('CID') def test_do_cluster_delete_not_found(self): - client = mock.Mock() + service = mock.Mock() args = {'id': ['cluster_id']} args = self._make_args(args) - ex = exc.HTTPNotFound - client.conn.cluster.delete_cluster.side_effect = ex + + service.delete_cluster.side_effect = exc.HTTPNotFound ex = self.assertRaises(exc.CommandError, - sh.do_cluster_delete, client, args) + sh.do_cluster_delete, service, args) msg = _('Failed to delete some of the specified clusters.') self.assertEqual(msg, six.text_type(ex)) @mock.patch.object(sh, '_show_cluster') def test_do_cluster_update(self, mock_show): - client = mock.Mock() + service = mock.Mock() args = { 'profile': 'test_profile', 'name': 'CLUSTER1', @@ -691,25 +693,26 @@ class ShellTest(testtools.TestCase): args.id = 'CID' cluster = mock.Mock() cluster.id = 'CID' - client.conn.cluster.get_cluster.return_value = cluster - client.conn.cluster.update_cluster = mock.Mock() - sh.do_cluster_update(client, args) - client.conn.cluster.get_cluster.assert_called_once_with('CID') - client.conn.cluster.update_cluster.assert_called_once_with('CID', - **attrs) - mock_show.assert_called_once_with(client, 'CID') + service.get_cluster.return_value = cluster + service.update_cluster = mock.Mock() + + sh.do_cluster_update(service, args) + + service.get_cluster.assert_called_once_with('CID') + service.update_cluster.assert_called_once_with('CID', **attrs) + mock_show.assert_called_once_with(service, 'CID') @mock.patch.object(sh, '_show_cluster') def test_do_cluster_show(self, mock_show): - client = mock.Mock() + service = mock.Mock() args = {'id': 'cluster_id'} args = self._make_args(args) - sh.do_cluster_show(client, args) - mock_show.assert_called_once_with(client, 'cluster_id') + sh.do_cluster_show(service, args) + mock_show.assert_called_once_with(service, 'cluster_id') @mock.patch.object(utils, 'print_list') def test_do_cluster_node_list(self, mock_print): - client = mock.Mock() + service = mock.Mock() args = { 'id': 'cluster_id', 'limit': 20, @@ -724,25 +727,24 @@ class ShellTest(testtools.TestCase): args = self._make_args(args) args.full_id = True nodes = mock.Mock() - client.nodes.return_value = nodes + service.nodes.return_value = nodes formatters = {} fields = ['id', 'name', 'index', 'status', 'physical_id', 'created_at'] - sh.do_cluster_node_list(client, args) - client.nodes.assert_called_once_with(**queries) + sh.do_cluster_node_list(service, args) + service.nodes.assert_called_once_with(**queries) mock_print.assert_called_once_with(nodes, fields, formatters=formatters, sortby_index=5) # node not found - ex = exc.HTTPNotFound - client.nodes.side_effect = ex + service.nodes.side_effect = exc.HTTPNotFound ex = self.assertRaises(exc.CommandError, - sh.do_cluster_node_list, client, args) + sh.do_cluster_node_list, service, args) msg = _('No node matching criteria is found') self.assertEqual(msg, six.text_type(ex)) def test_do_cluster_node_add(self): - client = mock.Mock() + service = mock.Mock() args = { 'id': 'cluster_id', 'nodes': 'node1,node2' @@ -750,13 +752,13 @@ class ShellTest(testtools.TestCase): args = self._make_args(args) node_ids = ['node1', 'node2'] resp = {'action': 'CLUSTER_NODE_ADD'} - client.conn.cluster.cluster_add_nodes.return_value = resp - sh.do_cluster_node_add(client, args) - client.conn.cluster.cluster_add_nodes.assert_called_once_with( + service.cluster_add_nodes.return_value = resp + sh.do_cluster_node_add(service, args) + service.cluster_add_nodes.assert_called_once_with( 'cluster_id', node_ids) def test_do_cluster_node_del(self): - client = mock.Mock() + service = mock.Mock() args = { 'id': 'cluster_id', 'nodes': 'node1,node2' @@ -764,13 +766,15 @@ class ShellTest(testtools.TestCase): args = self._make_args(args) node_ids = ['node1', 'node2'] resp = {'action': 'CLUSTER_NODE_DEL'} - client.conn.cluster.cluster_del_nodes.return_value = resp - sh.do_cluster_node_del(client, args) - client.conn.cluster.cluster_del_nodes.assert_called_once_with( - 'cluster_id', node_ids) + service.cluster_del_nodes.return_value = resp + + sh.do_cluster_node_del(service, args) + + service.cluster_del_nodes.assert_called_once_with('cluster_id', + node_ids) def test_do_cluster_resize(self): - client = mock.Mock() + service = mock.Mock() args = { 'id': 'cluster_id', 'capacity': 2, @@ -784,7 +788,7 @@ class ShellTest(testtools.TestCase): args = self._make_args(args) ex = self.assertRaises(exc.CommandError, sh.do_cluster_resize, - client, args) + service, args) msg = _("Only one of 'capacity', 'adjustment' and " "'percentage' can be specified.") self.assertEqual(msg, six.text_type(ex)) @@ -802,16 +806,15 @@ class ShellTest(testtools.TestCase): 'min_step': None, } resp = {'action': 'action_id'} - client.conn.cluster.cluster_resize.return_value = resp - sh.do_cluster_resize(client, args) - client.conn.cluster.cluster_resize.assert_called_with( - 'cluster_id', **action_args) + service.cluster_resize.return_value = resp + sh.do_cluster_resize(service, args) + service.cluster_resize.assert_called_with('cluster_id', **action_args) # capacity is smaller than 0 args.capacity = -1 ex = self.assertRaises(exc.CommandError, sh.do_cluster_resize, - client, args) + service, args) msg = _('Cluster capacity must be larger than ' ' or equal to zero.') self.assertEqual(msg, six.text_type(ex)) @@ -822,15 +825,14 @@ class ShellTest(testtools.TestCase): args.adjustment = 1 action_args['adjustment_type'] = 'CHANGE_IN_CAPACITY' action_args['number'] = 1 - sh.do_cluster_resize(client, args) - client.conn.cluster.cluster_resize.assert_called_with( - 'cluster_id', **action_args) + sh.do_cluster_resize(service, args) + service.cluster_resize.assert_called_with('cluster_id', **action_args) # adjustment is 0 args.adjustment = 0 ex = self.assertRaises(exc.CommandError, sh.do_cluster_resize, - client, args) + service, args) msg = _('Adjustment cannot be zero.') self.assertEqual(msg, six.text_type(ex)) @@ -840,15 +842,14 @@ class ShellTest(testtools.TestCase): args.adjustment = None action_args['adjustment_type'] = 'CHANGE_IN_PERCENTAGE' action_args['number'] = 50.0 - sh.do_cluster_resize(client, args) - client.conn.cluster.cluster_resize.assert_called_with( - 'cluster_id', **action_args) + sh.do_cluster_resize(service, args) + service.cluster_resize.assert_called_with('cluster_id', **action_args) # percentage is 0 args.percentage = 0 ex = self.assertRaises(exc.CommandError, sh.do_cluster_resize, - client, args) + service, args) msg = _('Percentage cannot be zero.') self.assertEqual(msg, six.text_type(ex)) @@ -859,7 +860,7 @@ class ShellTest(testtools.TestCase): args.min_step = 1 ex = self.assertRaises(exc.CommandError, sh.do_cluster_resize, - client, args) + service, args) msg = _('Min step is only used with percentage.') self.assertEqual(msg, six.text_type(ex)) @@ -871,7 +872,7 @@ class ShellTest(testtools.TestCase): args.min_size = -1 ex = self.assertRaises(exc.CommandError, sh.do_cluster_resize, - client, args) + service, args) msg = _('Min size cannot be less than zero.') self.assertEqual(msg, six.text_type(ex)) @@ -884,7 +885,7 @@ class ShellTest(testtools.TestCase): args.max_size = 4 ex = self.assertRaises(exc.CommandError, sh.do_cluster_resize, - client, args) + service, args) msg = _('Min size cannot be larger than max size.') self.assertEqual(msg, six.text_type(ex)) @@ -897,7 +898,7 @@ class ShellTest(testtools.TestCase): args.max_size = 8 ex = self.assertRaises(exc.CommandError, sh.do_cluster_resize, - client, args) + service, args) msg = _('Min size cannot be larger than the specified capacity') self.assertEqual(msg, six.text_type(ex)) @@ -910,43 +911,44 @@ class ShellTest(testtools.TestCase): args.max_size = 4 ex = self.assertRaises(exc.CommandError, sh.do_cluster_resize, - client, args) + service, args) msg = _('Max size cannot be less than the specified capacity.') self.assertEqual(msg, six.text_type(ex)) def test_do_cluster_scale_out(self): - client = mock.Mock() + service = mock.Mock() args = { 'id': 'cluster_id', 'count': 3, } args = self._make_args(args) resp = {'action': 'action_id'} - client.conn.cluster.cluster_scale_out.return_value = resp - sh.do_cluster_scale_out(client, args) - client.conn.cluster.cluster_scale_out.assert_called_once_with( + service.cluster_scale_out.return_value = resp + sh.do_cluster_scale_out(service, args) + service.cluster_scale_out.assert_called_once_with( 'cluster_id', 3) def test_do_cluster_scale_in(self): - client = mock.Mock() + service = mock.Mock() args = { 'id': 'cluster_id', 'count': 3, } args = self._make_args(args) resp = {'action': 'action_id'} - client.conn.cluster.cluster_scale_in.return_value = resp - sh.do_cluster_scale_in(client, args) - client.conn.cluster.cluster_scale_in.assert_called_once_with( - 'cluster_id', 3) + service.cluster_scale_in.return_value = resp + + sh.do_cluster_scale_in(service, args) + + service.cluster_scale_in.assert_called_once_with('cluster_id', 3) @mock.patch.object(utils, 'print_list') def test_do_cluster_policy_list(self, mock_print): fields = ['policy_id', 'policy', 'type', 'priority', 'level', 'cooldown', 'enabled'] - client = mock.Mock() + service = mock.Mock() args = { - 'id': 'cluster_id', + 'id': 'C1', 'filters': ['enabled=True'], 'sort_keys': 'level', 'sort_dir': 'asc', @@ -959,54 +961,48 @@ class ShellTest(testtools.TestCase): 'enabled': 'True', } cluster = mock.Mock() - cluster.id = 'cluster_id' - client.get_cluster.return_value = cluster + cluster.id = 'C1' + service.get_cluster.return_value = cluster policies = mock.Mock() - client.cluster_policies.return_value = policies - sh.do_cluster_policy_list(client, args) - client.get_cluster.assert_called_once_with('cluster_id') - client.cluster_policies.assert_called_once_with('cluster_id', - **queries) + service.cluster_policies.return_value = policies + sh.do_cluster_policy_list(service, args) + service.get_cluster.assert_called_once_with('C1') + service.cluster_policies.assert_called_once_with('C1', **queries) formatters = {} mock_print.assert_called_once_with(policies, fields, formatters=formatters, sortby_index=None) # wrong sort_key - args.sort_keys = 'level;wrong_key' - ex = exc.CommandError - ex = self.assertRaises(ex, + args.sort_keys = 'level;BADKEY' + ex = self.assertRaises(exc.CommandError, sh.do_cluster_policy_list, - client, args) - msg = _('Invalid sorting key: wrong_key') + service, args) + msg = _('Invalid sorting key: BADKEY') self.assertEqual(msg, six.text_type(ex)) @mock.patch.object(utils, 'print_dict') def test_do_cluster_policy_show(self, mock_print): - client = mock.Mock() - args = { - 'id': 'cluster1', - 'policy': 'policy1', - } - args = self._make_args(args) - queries = { - 'cluster_id': 'cluster1', - 'policy_id': 'policy1', - } - class Binding(object): def to_dict(self): pass + + service = mock.Mock() + args = { + 'id': 'CC', + 'policy': 'PP', + } + args = self._make_args(args) binding = Binding() - client.get_cluster_policy.return_value = binding - sh.do_cluster_policy_show(client, args) - client.get_cluster_policy.assert_called_once_with(queries) + service.get_cluster_policy.return_value = binding + sh.do_cluster_policy_show(service, args) + service.get_cluster_policy.assert_called_once_with('PP', 'CC') mock_print.assert_called_once_with(binding.to_dict()) def test_do_cluster_policy_attach(self): - client = mock.Mock() + service = mock.Mock() args = { - 'id': 'cluster1', - 'policy': 'policy1', + 'id': 'C1', + 'policy': 'P1', 'priority': 50, 'enforcement_level': 60, 'cooldown': 120, @@ -1019,29 +1015,27 @@ class ShellTest(testtools.TestCase): 'cooldown': 120, 'enabled': 'True', } - resp = {'action': 'action_id'} - client.conn.cluster.cluster_attach_policy.return_value = resp - sh.do_cluster_policy_attach(client, args) - client.conn.cluster.cluster_attach_policy.assert_called_once_with( - 'cluster1', 'policy1', **kwargs) + service.cluster_attach_policy.return_value = {'action': 'action_id'} + sh.do_cluster_policy_attach(service, args) + service.cluster_attach_policy.assert_called_once_with('C1', 'P1', + **kwargs) def test_do_cluster_policy_detach(self): args = { - 'id': 'cluster1', - 'policy': 'policy1' + 'id': 'CC', + 'policy': 'PP' } - client = mock.Mock() + service = mock.Mock() args = self._make_args(args) resp = {'action': 'action_id'} - client.conn.cluster.cluster_detach_policy.return_value = resp - sh.do_cluster_policy_detach(client, args) - client.conn.cluster.cluster_detach_policy.assert_called_once_with( - 'cluster1', 'policy1') + service.cluster_detach_policy.return_value = resp + sh.do_cluster_policy_detach(service, args) + service.cluster_detach_policy.assert_called_once_with('CC', 'PP') def test_do_cluster_policy_update(self): - client = mock.Mock() + service = mock.Mock() args = { - 'id': 'cluster1', + 'id': 'C1', 'policy': 'policy1', 'priority': 50, 'enforcement_level': 60, @@ -1056,41 +1050,39 @@ class ShellTest(testtools.TestCase): 'cooldown': 120, 'enabled': 'True', } - resp = {'action': 'action_id'} - client.conn.cluster.cluster_update_policy.return_value = resp - sh.do_cluster_policy_update(client, args) - client.conn.cluster.cluster_update_policy.assert_called_once_with( - 'cluster1', **kwargs) + service.cluster_update_policy.return_value = {'action': 'action_id'} + + sh.do_cluster_policy_update(service, args) + + service.cluster_update_policy.assert_called_once_with('C1', **kwargs) def test_do_cluster_policy_enable(self): args = { - 'id': 'cluster1', - 'policy': 'policy1' + 'id': 'CC', + 'policy': 'PP' } args = self._make_args(args) - client = mock.Mock() + service = mock.Mock() resp = {'action': 'action_id'} - client.conn.cluster.cluster_enable_policy.return_value = resp - sh.do_cluster_policy_enable(client, args) - client.conn.cluster.cluster_enable_policy.assert_called_once_with( - 'cluster1', 'policy1') + service.cluster_enable_policy.return_value = resp + sh.do_cluster_policy_enable(service, args) + service.cluster_enable_policy.assert_called_once_with('CC', 'PP') def test_do_cluster_policy_disable(self): args = { - 'id': 'cluster1', - 'policy': 'policy1' + 'id': 'CC', + 'policy': 'PP' } args = self._make_args(args) - client = mock.Mock() + service = mock.Mock() resp = {'action': 'action_id'} - client.conn.cluster.cluster_disable_policy.return_value = resp - sh.do_cluster_policy_disable(client, args) - client.conn.cluster.cluster_disable_policy.assert_called_once_with( - 'cluster1', 'policy1') + service.cluster_disable_policy.return_value = resp + sh.do_cluster_policy_disable(service, args) + service.cluster_disable_policy.assert_called_once_with('CC', 'PP') @mock.patch.object(utils, 'print_list') def test_do_node_list(self, mock_print): - client = mock.Mock() + service = mock.Mock() fields = ['id', 'name', 'status', 'cluster_id', 'physical_id', 'profile_name', 'created_at', 'updated_at'] args = { @@ -1114,35 +1106,38 @@ class ShellTest(testtools.TestCase): } args = self._make_args(args) nodes = mock.Mock() - client.nodes.return_value = nodes + service.nodes.return_value = nodes formatters = {} - sh.do_node_list(client, args) + sh.do_node_list(service, args) mock_print.assert_called_once_with(nodes, fields, formatters=formatters, sortby_index=None) - client.nodes.assert_called_once_with(**queries) + service.nodes.assert_called_once_with(**queries) + # wrong sort key - args.sort_keys = 'name;wrong_key' + args.sort_keys = 'name;BADKEY' ex = exc.CommandError - ex = self.assertRaises(ex, sh.do_node_list, client, args) - msg = _('Invalid sorting key: wrong_key') + ex = self.assertRaises(ex, sh.do_node_list, service, args) + msg = _('Invalid sorting key: BADKEY') self.assertEqual(msg, six.text_type(ex)) @mock.patch.object(utils, 'print_dict') @mock.patch.object(utils, 'nested_dict_formatter') def test_show_node(self, mock_nested, mock_print): - client = mock.Mock() + service = mock.Mock() node_id = 'node1' node = mock.Mock() - client.get_node.return_value = node + service.get_node.return_value = node formatters = { 'metadata': utils.json_formatter, 'data': utils.json_formatter, } data = mock.Mock() node.to_dict.return_value = data - sh._show_node(client, node_id, show_details=False) - client.get_node.assert_called_once_with(node_id, False) + + sh._show_node(service, node_id, show_details=False) + + service.get_node.assert_called_once_with(node_id) mock_print.assert_called_once_with(data, formatters=formatters) @mock.patch.object(sh, '_show_node') @@ -1162,46 +1157,48 @@ class ShellTest(testtools.TestCase): 'role': 'master', 'metadata': {'user': 'demo'}, } - client = mock.Mock() + service = mock.Mock() node = mock.Mock() node.id = 'node_id' - client.create_node.return_value = node - sh.do_node_create(client, args) - client.create_node.assert_called_once_with(**attrs) - mock_show.assert_called_once_with(client, 'node_id') + service.create_node.return_value = node + sh.do_node_create(service, args) + service.create_node.assert_called_once_with(**attrs) + mock_show.assert_called_once_with(service, 'node_id') @mock.patch.object(sh, '_show_node') def test_do_node_show(self, mock_show): - client = mock.Mock() + service = mock.Mock() args = { 'id': 'node1', 'details': False } args = self._make_args(args) - sh.do_node_show(client, args) - mock_show.assert_called_once_with(client, 'node1', False) + sh.do_node_show(service, args) + mock_show.assert_called_once_with(service, 'node1', False) def test_do_node_delete(self): - client = mock.Mock() - args = { - 'id': ['node1'] - } - args = self._make_args(args) - client.delete_node = mock.Mock() - sh.do_node_delete(client, args) - client.delete_node.assert_called_once_with('node1') + service = mock.Mock() + args = self._make_args({'id': ['node1']}) + service.delete_node = mock.Mock() - # node not found + sh.do_node_delete(service, args) + + service.delete_node.assert_called_once_with('node1', True) + + def test_do_node_delete_not_found(self): + service = mock.Mock() ex = exc.HTTPNotFound - client.delete_node.side_effect = ex + service.delete_node.side_effect = ex + + args = self._make_args({'id': ['node1']}) ex = self.assertRaises(exc.CommandError, - sh.do_node_delete, client, args) + sh.do_node_delete, service, args) msg = _('Failed to delete some of the specified nodes.') self.assertEqual(msg, six.text_type(ex)) @mock.patch.object(sh, '_show_node') def test_do_node_update(self, mock_show): - client = mock.Mock() + service = mock.Mock() args = { 'id': 'node_id', 'name': 'node1', @@ -1218,42 +1215,42 @@ class ShellTest(testtools.TestCase): } node = mock.Mock() node.id = 'node_id' - client.get_node.return_value = node - sh.do_node_update(client, args) - client.get_node.assert_called_once_with('node_id') - client.update_node.assert_called_once_with('node_id', **attrs) - mock_show.assert_called_once_with(client, 'node_id') + service.get_node.return_value = node + sh.do_node_update(service, args) + service.get_node.assert_called_once_with('node_id') + service.update_node.assert_called_once_with('node_id', **attrs) + mock_show.assert_called_once_with(service, 'node_id') @mock.patch.object(sh, '_show_node') def test_do_node_join(self, mock_show): - client = mock.Mock() + service = mock.Mock() args = { 'id': 'node1', 'cluster': 'cluster1' } args = self._make_args(args) resp = {'action': 'action_id'} - client.node_join.return_value = resp - sh.do_node_join(client, args) - client.node_join.assert_called_once_with('node1', 'cluster1') - mock_show.assert_called_once_with(client, 'node1') + service.node_join.return_value = resp + sh.do_node_join(service, args) + service.node_join.assert_called_once_with('node1', 'cluster1') + mock_show.assert_called_once_with(service, 'node1') @mock.patch.object(sh, '_show_node') def test_do_node_leave(self, mock_show): - client = mock.Mock() + service = mock.Mock() args = { 'id': 'node1', } args = self._make_args(args) resp = {'action': 'action_id'} - client.node_leave.return_value = resp - sh.do_node_leave(client, args) - client.node_leave.assert_called_once_with('node1') - mock_show.assert_called_once_with(client, 'node1') + service.node_leave.return_value = resp + sh.do_node_leave(service, args) + service.node_leave.assert_called_once_with('node1') + mock_show.assert_called_once_with(service, 'node1') @mock.patch.object(utils, 'print_list') def test_do_event_list(self, mock_print): - client = mock.Mock() + service = mock.Mock() fields = ['id', 'timestamp', 'obj_type', 'obj_id', 'obj_name', 'action', 'status', 'status_reason', 'level'] args = { @@ -1273,47 +1270,53 @@ class ShellTest(testtools.TestCase): sortby_index = None formatters = {} events = mock.Mock() - client.events.return_value = events - sh.do_event_list(client, args) - client.events.assert_called_once_with(**queries) + service.events.return_value = events + + sh.do_event_list(service, args) + + service.events.assert_called_once_with(**queries) mock_print.assert_called_once_with(events, fields, formatters=formatters, sortby_index=sortby_index) # invalid sorting key args.sort_keys = 'wrong_key' - ex = exc.CommandError - ex = self.assertRaises(ex, + ex = self.assertRaises(exc.CommandError, sh.do_event_list, - client, args) + service, args) msg = _('Invalid sorting key: wrong_key') self.assertEqual(msg, six.text_type(ex)) @mock.patch.object(utils, 'print_dict') def test_do_event_show(self, mock_print): - client = mock.Mock() + class FakeEvent(object): + def to_dict(self): + pass + + service = mock.Mock() args = { 'id': 'event_id' } args = self._make_args(args) - class Event(object): - def to_dict(self): - pass - event = Event() - client.get_event.return_value = event - sh.do_event_show(client, args) - client.get_event.assert_called_once_with('event_id') + event = FakeEvent() + service.get_event.return_value = event + sh.do_event_show(service, args) + service.get_event.assert_called_once_with('event_id') mock_print.assert_called_once_with(event.to_dict()) + + def test_do_event_show_not_found(self): + service = mock.Mock() + args = self._make_args({'id': 'FAKE'}) # event not found ex = exc.CommandError - client.get_event.side_effect = exc.HTTPNotFound + service.get_event.side_effect = exc.HTTPNotFound ex = self.assertRaises(ex, sh.do_event_show, - client, args) + service, args) @mock.patch.object(utils, 'print_list') def test_do_action_list(self, mock_print): - client = mock.Mock() + service = mock.Mock() fields = ['id', 'name', 'action', 'status', 'target', 'depends_on', 'depended_by'] args = { @@ -1327,56 +1330,64 @@ class ShellTest(testtools.TestCase): args.filters = ['status=ACTIVE'] queries['status'] = 'ACTIVE' actions = mock.Mock() - client.actions.return_value = actions + service.actions.return_value = actions formatters = { 'depends_on': mock.ANY, 'depended_by': mock.ANY } args.full_id = True sortby_index = None - sh.do_action_list(client, args) - client.actions.assert_called_once_with(**queries) + sh.do_action_list(service, args) + service.actions.assert_called_once_with(**queries) mock_print.assert_called_once_with(actions, fields, formatters=formatters, sortby_index=sortby_index) - # invalid sorting key - args.sort_keys = 'wrong_key' - ex = exc.CommandError - ex = self.assertRaises(ex, - sh.do_action_list, - client, args) - msg = _('Invalid sorting key: wrong_key') + + def test_do_action_list_invalid_sorting_key(self): + service = mock.Mock() + args = { + 'sort_keys': 'BOGUS', + 'sort_dir': 'asc', + 'limit': 20, + 'marker': 'marker_id', + 'filters': ['status=ACTIVE'] + } + args = self._make_args(args) + + ex = self.assertRaises(exc.CommandError, sh.do_action_list, + service, args) + msg = _('Invalid sorting key: BOGUS') self.assertEqual(msg, six.text_type(ex)) @mock.patch.object(utils, 'print_dict') def test_do_action_show(self, mock_print): - client = mock.Mock() - args = { - 'id': 'action_id' - } - args = self._make_args(args) - - class Action(object): + class FakeAction(object): def to_dict(self): pass - action = Action() - client.get_action.return_value = action + + service = mock.Mock() + args = self._make_args({'id': 'action_id'}) + + action = FakeAction() + service.get_action.return_value = action formatters = { 'inputs': utils.json_formatter, 'outputs': utils.json_formatter, 'metadata': utils.json_formatter, 'data': utils.json_formatter, } - sh.do_action_show(client, args) - client.get_action.assert_called_once_with('action_id') + sh.do_action_show(service, args) + service.get_action.assert_called_once_with('action_id') mock_print.assert_called_once_with(action.to_dict(), formatters=formatters) - # action not found - args.id = 'fake_id' - ex = exc.CommandError - client.get_action.side_effect = exc.HTTPNotFound - ex = self.assertRaises(ex, + + def test_do_action_show_not_found(self): + service = mock.Mock() + args = self._make_args({'id': 'fake_id'}) + + service.get_action.side_effect = exc.HTTPNotFound + ex = self.assertRaises(exc.CommandError, sh.do_action_show, - client, args) + service, args) msg = _('Action fake_id is not found') self.assertEqual(msg, six.text_type(ex)) diff --git a/senlinclient/v1/client.py b/senlinclient/v1/client.py index 8b246587..01b3f317 100644 --- a/senlinclient/v1/client.py +++ b/senlinclient/v1/client.py @@ -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) diff --git a/senlinclient/v1/shell.py b/senlinclient/v1/shell.py index 9b08c3db..e4fad771 100644 --- a/senlinclient/v1/shell.py +++ b/senlinclient/v1/shell.py @@ -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='', 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='', 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='', @@ -169,7 +169,7 @@ def do_profile_show(sc, args): action='append') @utils.arg('id', metavar='', 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='', 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='', 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='', 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='', @@ -315,7 +315,7 @@ def do_policy_show(sc, args): help=_('New name of the policy to be updated.')) @utils.arg('id', metavar='', 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='', 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='', 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='', 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='', 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='', 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='', @@ -534,7 +534,7 @@ def do_cluster_show(sc, args): help=_('Print full IDs in list.')) @utils.arg('id', metavar='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', 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='', default='webhook', @@ -1133,7 +1130,7 @@ def do_receiver_show(sc, args): action='append') @utils.arg('name', metavar='', 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='', 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='', 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='', 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)