x/python-moganclient
Code Issues Proposed changes

Add server group commands support

Browse Source 
Partially Implements: bp server-group-api-extension
Change-Id: I8cb665cdd83a97de578ab80a2725851f63d49356
This commit is contained in:
liusheng 2017-08-16 10:10:41 +08:00
parent 01c02f8f7b
commit 88d1b8c603
7 changed files with 522 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

191
moganclient/osc/v1/server_group.py Normal file
View File

@ -0,0 +1,191 @@
# Copyright 2017 Huawei, Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
"""Mogan v1 Baremetal Server Group action implementations"""
import logging
from osc_lib.command import command
from osc_lib import exceptions
from osc_lib import utils
from openstackclient.i18n import _
LOG = logging.getLogger(__name__)
_formatters = {
'policies': utils.format_list,
'members': utils.format_list,
}
class CreateServerGroup(command.ShowOne):
"""Create a new baremetal server group"""
def get_parser(self, prog_name):
parser = super(CreateServerGroup, self).get_parser(prog_name)
parser.add_argument(
'name',
metavar='<name>',
help=_("New baremetal server group name")
)
parser.add_argument(
'--policy',
metavar='<policy>',
choices=['affinity', 'anti-affinity'],
default='affinity',
help=_("Add a policy to <name> "
"('affinity' or 'anti-affinity', "
"default to 'affinity')")
)
return parser
def take_action(self, parsed_args):
bc_client = self.app.client_manager.baremetal_compute
info = {}
server_group = bc_client.server_group.create(
name=parsed_args.name,
policies=[parsed_args.policy])
info.update(server_group._info)
columns = (
'uuid',
'name',
'user_id',
'project_id',
'members',
'policies',
)
data = utils.get_dict_properties(info, columns,
formatters=_formatters)
return columns, data
class DeleteServerGroup(command.Command):
"""Delete existing baremetal server group(s)."""
def get_parser(self, prog_name):
parser = super(DeleteServerGroup, self).get_parser(prog_name)
parser.add_argument(
'server_group',
metavar='<server-group>',
nargs='+',
help=_("Baremetal server group(s) to delete (name or ID)")
)
return parser
def take_action(self, parsed_args):
bc_client = self.app.client_manager.baremetal_compute
result = 0
for group in parsed_args.server_group:
try:
group_obj = utils.find_resource(bc_client.server_group,
group)
bc_client.server_group.delete(group_obj.uuid)
# Catch all exceptions in order to avoid to block the next deleting
except Exception as e:
result += 1
LOG.error(e)
if result > 0:
total = len(parsed_args.server_group)
msg = _("%(result)s of %(total)s baremetal server groups failed "
"to delete.")
raise exceptions.CommandError(
msg % {"result": result,
"total": total}
)
class ListServerGroup(command.Lister):
"""List all baremetal server groups."""
def get_parser(self, prog_name):
parser = super(ListServerGroup, self).get_parser(prog_name)
parser.add_argument(
'--all-projects',
action='store_true',
default=False,
help=_("Display information from all projects (admin only)")
)
parser.add_argument(
'--long',
action='store_true',
default=False,
help=_("List additional fields in output")
)
return parser
def take_action(self, parsed_args):
bc_client = self.app.client_manager.baremetal_compute
data = bc_client.server_group.list(parsed_args.all_projects)
if parsed_args.long:
column_headers = columns = (
'UUID',
'Name',
'Policies',
'Members',
'Project Id',
'User Id',
)
else:
column_headers = columns = (
'UUID',
'Name',
'Policies',
)
return (column_headers,
(utils.get_item_properties(
s, columns,
formatters={
'Policies': utils.format_list,
'Members': utils.format_list,
}
) for s in data))
class ShowServerGroup(command.ShowOne):
"""Display baremetal server group details."""
def get_parser(self, prog_name):
parser = super(ShowServerGroup, self).get_parser(prog_name)
parser.add_argument(
'server_group',
metavar='<server-group>',
help=_("Baremetal server group to display (name or ID)")
)
return parser
def take_action(self, parsed_args):
bc_client = self.app.client_manager.baremetal_compute
group = utils.find_resource(bc_client.server_group,
parsed_args.server_group)
info = {}
info.update(group._info)
columns = (
'uuid',
'name',
'user_id',
'project_id',
'members',
'policies',
)
data = utils.get_dict_properties(info, columns,
formatters=_formatters)
return columns, data

38
moganclient/tests/unit/fakes.py
View File

@ -26,6 +26,7 @@ from moganclient.v1 import availability_zone
from moganclient.v1 import flavor
from moganclient.v1 import node
from moganclient.v1 import server
from moganclient.v1 import server_group
# fake request id
@ -69,6 +70,8 @@ class FakeBaremetalComputeV1Client(object):
self.fake_http_client)
self.node = node.NodeManager(self.fake_http_client)
self.aggregate = aggregate.AggregateManager(self.fake_http_client)
self.server_group = server_group.ServerGroupManager(
self.fake_http_client)
class FakeHTTPClient(object):
@ -396,3 +399,38 @@ class FakeAggregate(object):
if aggregates is None:
aggregates = FakeAggregate.create_aggregates(count)
return mock.Mock(side_effect=aggregates)
class FakeServerGroup(object):
"""Fake one baremetal server group"""
@staticmethod
def create_one_server_group(attrs=None):
"""Create a fake baremetal server group
:param Dictionary attrs:
A dictionary with all attributes
:return:
A FakeResource object, with id and other attributes
"""
if attrs is None:
attrs = {}
# Set default attributes.
server_group_info = {
'uuid': 'sg-id-' + uuidutils.generate_uuid(dashed=False),
'members': [],
'name': 'sg-name-' + uuidutils.generate_uuid(dashed=False),
'policies': [],
'project_id': 'project-' + uuidutils.generate_uuid(dashed=False),
'user_id': 'user-' + uuidutils.generate_uuid(dashed=False),
}
# Overwrite default attributes.
server_group_info.update(attrs)
server_group = FakeResource(
manager=None,
info=copy.deepcopy(server_group_info),
loaded=True)
return server_group

243
moganclient/tests/unit/osc/v1/test_server_group.py Normal file
View File

@ -0,0 +1,243 @@
# Copyright 2017 Huawei, Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
import fixtures
import mock
from osc_lib import exceptions
from osc_lib import utils
from moganclient.osc.v1 import server_group
from moganclient.tests.unit import base as test_base
from moganclient.tests.unit import fakes
class TestServerGroup(test_base.TestBaremetalComputeV1):
fake_server_group = fakes.FakeServerGroup.create_one_server_group()
columns = (
'uuid',
'name',
'user_id',
'project_id',
'members',
'policies',
)
data = (
fake_server_group.uuid,
fake_server_group.name,
fake_server_group.user_id,
fake_server_group.project_id,
utils.format_list(fake_server_group.members),
utils.format_list(fake_server_group.policies),
)
def setUp(self):
self.server_group_mock = mock.Mock()
self.useFixture(fixtures.MockPatch(
'moganclient.v1.server_group.ServerGroupManager',
return_value=self.server_group_mock))
super(TestServerGroup, self).setUp()
class TestServerGroupCreate(TestServerGroup):
def setUp(self):
super(TestServerGroupCreate, self).setUp()
self.server_group_mock.create.return_value = self.fake_server_group
self.cmd = server_group.CreateServerGroup(self.app, None)
def test_server_group_create(self):
arglist = [
'--policy', 'anti-affinity',
'affinity_group',
]
verifylist = [
('policy', 'anti-affinity'),
('name', 'affinity_group'),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.server_group_mock.create.assert_called_once_with(
name=parsed_args.name,
policies=[parsed_args.policy],
)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)
class TestServerGroupDelete(TestServerGroup):
def setUp(self):
super(TestServerGroupDelete, self).setUp()
self.server_group_mock.get.return_value = self.fake_server_group
self.cmd = server_group.DeleteServerGroup(self.app, None)
def test_server_group_delete(self):
arglist = [
'affinity_group',
]
verifylist = [
('server_group', ['affinity_group']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.server_group_mock.get.assert_called_once_with('affinity_group')
self.server_group_mock.delete.assert_called_once_with(
self.fake_server_group.uuid
)
self.assertIsNone(result)
def test_server_group_multiple_delete(self):
arglist = [
'affinity_group',
'anti_affinity_group'
]
verifylist = [
('server_group', ['affinity_group', 'anti_affinity_group']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
result = self.cmd.take_action(parsed_args)
self.server_group_mock.get.assert_any_call('affinity_group')
self.server_group_mock.get.assert_any_call('anti_affinity_group')
self.server_group_mock.delete.assert_called_with(
self.fake_server_group.uuid
)
self.assertEqual(2, self.server_group_mock.get.call_count)
self.assertEqual(2, self.server_group_mock.delete.call_count)
self.assertIsNone(result)
def test_server_group_multiple_delete_with_exception(self):
arglist = [
'affinity_group',
'anti_affinity_group'
]
verifylist = [
('server_group', ['affinity_group', 'anti_affinity_group']),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
find_mock_result = [self.fake_server_group, exceptions.CommandError]
with mock.patch.object(utils, 'find_resource',
side_effect=find_mock_result) as find_mock:
try:
self.cmd.take_action(parsed_args)
self.fail('CommandError should be raised.')
except exceptions.CommandError as e:
self.assertEqual(
'1 of 2 baremetal server groups failed to delete.',
str(e))
find_mock.assert_any_call(self.server_group_mock,
'affinity_group')
find_mock.assert_any_call(self.server_group_mock,
'anti_affinity_group')
self.assertEqual(2, find_mock.call_count)
self.server_group_mock.delete.assert_called_once_with(
self.fake_server_group.uuid
)
class TestServerGroupList(TestServerGroup):
list_columns = (
'UUID',
'Name',
'Policies',
)
list_columns_long = (
'UUID',
'Name',
'Policies',
'Members',
'Project Id',
'User Id',
)
list_data = ((
TestServerGroup.fake_server_group.uuid,
TestServerGroup.fake_server_group.name,
utils.format_list(TestServerGroup.fake_server_group.policies),
),)
list_data_long = ((
TestServerGroup.fake_server_group.uuid,
TestServerGroup.fake_server_group.name,
utils.format_list(TestServerGroup.fake_server_group.policies),
utils.format_list(TestServerGroup.fake_server_group.members),
TestServerGroup.fake_server_group.project_id,
TestServerGroup.fake_server_group.user_id,
),)
def setUp(self):
super(TestServerGroupList, self).setUp()
self.server_group_mock.list.return_value = [self.fake_server_group]
self.cmd = server_group.ListServerGroup(self.app, None)
def test_server_group_list(self):
arglist = []
verifylist = [
('all_projects', False),
('long', False),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.server_group_mock.list.assert_called_once_with(False)
self.assertEqual(self.list_columns, columns)
self.assertEqual(self.list_data, tuple(data))
def test_server_group_list_with_all_projects_and_long(self):
arglist = [
'--all-projects',
'--long',
]
verifylist = [
('all_projects', True),
('long', True),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.server_group_mock.list.assert_called_once_with(True)
self.assertEqual(self.list_columns_long, columns)
self.assertEqual(self.list_data_long, tuple(data))
class TestServerGroupShow(TestServerGroup):
def setUp(self):
super(TestServerGroupShow, self).setUp()
self.server_group_mock.get.return_value = self.fake_server_group
self.cmd = server_group.ShowServerGroup(self.app, None)
def test_server_group_show(self):
arglist = [
'affinity_group',
]
verifylist = [
('server_group', 'affinity_group'),
]
parsed_args = self.check_parser(self.cmd, arglist, verifylist)
columns, data = self.cmd.take_action(parsed_args)
self.assertEqual(self.columns, columns)
self.assertEqual(self.data, data)

2
moganclient/v1/client.py
View File

@ -20,6 +20,7 @@ from moganclient.v1 import flavor
from moganclient.v1 import keypair
from moganclient.v1 import node
from moganclient.v1 import server
from moganclient.v1 import server_group
class Client(object):
@ -37,3 +38,4 @@ class Client(object):
self.keypair = keypair.KeyPairManager(self.http_client)
self.node = node.NodeManager(self.http_client)
self.aggregate = aggregate.AggregateManager(self.http_client)
self.server_group = server_group.ServerGroupManager(self.http_client)

43
moganclient/v1/server_group.py Normal file
View File

@ -0,0 +1,43 @@
# Copyright 2017 Huawei, Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
from moganclient.common import base
class ServerGroup(base.Resource):
pass
class ServerGroupManager(base.ManagerWithFind):
resource_class = ServerGroup
def create(self, name, policies):
url = '/server_groups'
data = {'name': name, 'policies': policies}
return self._create(url, data=data)
def delete(self, server_group):
url = '/server_groups/%s' % base.getid(server_group)
return self._delete(url)
def get(self, server_group):
url = '/server_groups/%s' % base.getid(server_group)
return self._get(url)
def list(self, all_projects=False):
url = '/server_groups'
if all_projects:
url += '?all_tenants=true'
return self._list(url, response_key='server_groups')

4
setup.cfg
View File

@ -65,6 +65,10 @@ openstack.baremetal_compute.v1 =
baremetal_aggregate_delete = moganclient.osc.v1.aggregate:DeleteAggregate
baremetal_aggregate_set = moganclient.osc.v1.aggregate:SetAggregate
baremetal_aggregate_unset = moganclient.osc.v1.aggregate:UnsetAggregate
baremetal_server_group_create = moganclient.osc.v1.server_group:CreateServerGroup
baremetal_server_group_show = moganclient.osc.v1.server_group:ShowServerGroup
baremetal_server_group_list = moganclient.osc.v1.server_group:ListServerGroup
baremetal_server_group_delete = moganclient.osc.v1.server_group:DeleteServerGroup
[build_sphinx]
source-dir = doc/source

1
test-requirements.txt
View File

@ -4,6 +4,7 @@
coverage!=4.4,>=4.0 # Apache-2.0
hacking!=0.13.0,<0.14,>=0.12.0 # Apache-2.0
fixtures>=3.0.0 # Apache-2.0/BSD
mock>=2.0 # BSD
python-openstackclient!=3.10.0,>=3.3.0 # Apache-2.0
python-subunit>=0.0.18 # Apache-2.0/BSD