7f617e6a21
There are usage patterns which would benefit from having the capability to send a list of resources in bulk instead of using individual fanout messages. From now on, the rpc callback subscriber receives a list of resources (single or multiple), and the pushers must always push a list. Backwards compatibility for QoSPolicy consumers in mitaka is provided by calling push with "resource" parameter for single item lists during one release cycle. That will be dropped when Ocata opens. Partially-implements: blueprint vlan-aware-vms Change-Id: I1117925360a29ecbd1902fa527b2f24f94ce81ec
305 lines
12 KiB
Python
305 lines
12 KiB
Python
# Copyright (c) 2015 Mellanox Technologies, Ltd
|
|
#
|
|
# 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 mock
|
|
from oslo_utils import uuidutils
|
|
from oslo_versionedobjects import fields as obj_fields
|
|
from oslo_versionedobjects import fixture
|
|
import testtools
|
|
|
|
from neutron.api.rpc.callbacks import resources
|
|
from neutron.api.rpc.callbacks import version_manager
|
|
from neutron.api.rpc.handlers import resources_rpc
|
|
from neutron.common import topics
|
|
from neutron import context
|
|
from neutron.objects import base as objects_base
|
|
from neutron.tests import base
|
|
|
|
|
|
TEST_EVENT = 'test_event'
|
|
TEST_VERSION = '1.0'
|
|
|
|
|
|
def _create_test_dict(uuid=None):
|
|
return {'id': uuid or uuidutils.generate_uuid(),
|
|
'field': 'foo'}
|
|
|
|
|
|
def _create_test_resource(context=None, resource_cls=None):
|
|
resource_cls = resource_cls or FakeResource
|
|
resource_dict = _create_test_dict()
|
|
resource = resource_cls(context, **resource_dict)
|
|
resource.obj_reset_changes()
|
|
return resource
|
|
|
|
|
|
class BaseFakeResource(objects_base.NeutronObject):
|
|
@classmethod
|
|
def get_objects(cls, context, **kwargs):
|
|
return list()
|
|
|
|
|
|
class FakeResource(BaseFakeResource):
|
|
VERSION = TEST_VERSION
|
|
|
|
fields = {
|
|
'id': obj_fields.UUIDField(),
|
|
'field': obj_fields.StringField()
|
|
}
|
|
|
|
|
|
class FakeResource2(BaseFakeResource):
|
|
VERSION = TEST_VERSION
|
|
|
|
fields = {
|
|
'id': obj_fields.UUIDField(),
|
|
'field': obj_fields.StringField()
|
|
}
|
|
|
|
|
|
class ResourcesRpcBaseTestCase(base.BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(ResourcesRpcBaseTestCase, self).setUp()
|
|
|
|
self.obj_registry = self.useFixture(
|
|
fixture.VersionedObjectRegistryFixture())
|
|
|
|
self.context = context.get_admin_context()
|
|
mock.patch.object(resources_rpc.resources,
|
|
'is_valid_resource_type').start()
|
|
mock.patch.object(resources_rpc.resources, 'get_resource_cls',
|
|
side_effect=self._get_resource_cls).start()
|
|
|
|
self.resource_objs = [_create_test_resource(self.context)
|
|
for _ in range(2)]
|
|
self.resource_objs2 = [_create_test_resource(self.context,
|
|
FakeResource2)
|
|
for _ in range(2)]
|
|
|
|
@staticmethod
|
|
def _get_resource_cls(resource_type):
|
|
return {FakeResource.obj_name(): FakeResource,
|
|
FakeResource2.obj_name(): FakeResource2}.get(resource_type)
|
|
|
|
|
|
class _ValidateResourceTypeTestCase(base.BaseTestCase):
|
|
def setUp(self):
|
|
super(_ValidateResourceTypeTestCase, self).setUp()
|
|
self.is_valid_mock = mock.patch.object(
|
|
resources_rpc.resources, 'is_valid_resource_type').start()
|
|
|
|
def test_valid_type(self):
|
|
self.is_valid_mock.return_value = True
|
|
resources_rpc._validate_resource_type('foo')
|
|
|
|
def test_invalid_type(self):
|
|
self.is_valid_mock.return_value = False
|
|
with testtools.ExpectedException(
|
|
resources_rpc.InvalidResourceTypeClass):
|
|
resources_rpc._validate_resource_type('foo')
|
|
|
|
|
|
class _ResourceTypeVersionedTopicTestCase(base.BaseTestCase):
|
|
|
|
@mock.patch.object(resources_rpc, '_validate_resource_type')
|
|
def test_resource_type_versioned_topic(self, validate_mock):
|
|
obj_name = FakeResource.obj_name()
|
|
expected = topics.RESOURCE_TOPIC_PATTERN % {
|
|
'resource_type': 'FakeResource', 'version': '1.0'}
|
|
with mock.patch.object(resources_rpc.resources, 'get_resource_cls',
|
|
return_value=FakeResource):
|
|
observed = resources_rpc.resource_type_versioned_topic(obj_name)
|
|
self.assertEqual(expected, observed)
|
|
|
|
|
|
class ResourcesPullRpcApiTestCase(ResourcesRpcBaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(ResourcesPullRpcApiTestCase, self).setUp()
|
|
self.rpc = resources_rpc.ResourcesPullRpcApi()
|
|
mock.patch.object(self.rpc, 'client').start()
|
|
self.cctxt_mock = self.rpc.client.prepare.return_value
|
|
|
|
def test_is_singleton(self):
|
|
self.assertIs(self.rpc, resources_rpc.ResourcesPullRpcApi())
|
|
|
|
def test_pull(self):
|
|
self.obj_registry.register(FakeResource)
|
|
expected_obj = _create_test_resource(self.context)
|
|
resource_id = expected_obj.id
|
|
self.cctxt_mock.call.return_value = expected_obj.obj_to_primitive()
|
|
|
|
result = self.rpc.pull(
|
|
self.context, FakeResource.obj_name(), resource_id)
|
|
|
|
self.cctxt_mock.call.assert_called_once_with(
|
|
self.context, 'pull', resource_type='FakeResource',
|
|
version=TEST_VERSION, resource_id=resource_id)
|
|
self.assertEqual(expected_obj, result)
|
|
|
|
def test_pull_resource_not_found(self):
|
|
resource_dict = _create_test_dict()
|
|
resource_id = resource_dict['id']
|
|
self.cctxt_mock.call.return_value = None
|
|
with testtools.ExpectedException(resources_rpc.ResourceNotFound):
|
|
self.rpc.pull(self.context, FakeResource.obj_name(),
|
|
resource_id)
|
|
|
|
|
|
class ResourcesPushToServerRpcCallbackTestCase(ResourcesRpcBaseTestCase):
|
|
|
|
def test_report_versions(self):
|
|
callbacks = resources_rpc.ResourcesPushToServerRpcCallback()
|
|
with mock.patch('neutron.api.rpc.callbacks.version_manager'
|
|
'.update_versions') as update_versions:
|
|
version_map = {'A': '1.0'}
|
|
callbacks.report_agent_resource_versions(context=mock.ANY,
|
|
agent_type='DHCP Agent',
|
|
agent_host='fake-host',
|
|
version_map=version_map)
|
|
update_versions.assert_called_once_with(mock.ANY,
|
|
version_map)
|
|
|
|
|
|
class ResourcesPullRpcCallbackTestCase(ResourcesRpcBaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(ResourcesPullRpcCallbackTestCase, self).setUp()
|
|
self.obj_registry.register(FakeResource)
|
|
self.callbacks = resources_rpc.ResourcesPullRpcCallback()
|
|
self.resource_obj = _create_test_resource(self.context)
|
|
|
|
def test_pull(self):
|
|
resource_dict = _create_test_dict(uuid=self.resource_obj.id)
|
|
with mock.patch.object(
|
|
resources_rpc.prod_registry, 'pull',
|
|
return_value=self.resource_obj) as registry_mock:
|
|
primitive = self.callbacks.pull(
|
|
self.context, resource_type=FakeResource.obj_name(),
|
|
version=TEST_VERSION,
|
|
resource_id=self.resource_obj.id)
|
|
registry_mock.assert_called_once_with(
|
|
'FakeResource', self.resource_obj.id, context=self.context)
|
|
self.assertEqual(resource_dict,
|
|
primitive['versioned_object.data'])
|
|
self.assertEqual(self.resource_obj.obj_to_primitive(), primitive)
|
|
|
|
@mock.patch.object(FakeResource, 'obj_to_primitive')
|
|
def test_pull_backports_to_older_version(self, to_prim_mock):
|
|
with mock.patch.object(resources_rpc.prod_registry, 'pull',
|
|
return_value=self.resource_obj):
|
|
self.callbacks.pull(
|
|
self.context, resource_type=FakeResource.obj_name(),
|
|
version='0.9', # less than initial version 1.0
|
|
resource_id=self.resource_obj.id)
|
|
to_prim_mock.assert_called_with(target_version='0.9')
|
|
|
|
|
|
class ResourcesPushRpcApiTestCase(ResourcesRpcBaseTestCase):
|
|
"""Tests the neutron server side of the RPC interface."""
|
|
|
|
def setUp(self):
|
|
super(ResourcesPushRpcApiTestCase, self).setUp()
|
|
mock.patch.object(resources_rpc.n_rpc, 'get_client').start()
|
|
self.rpc = resources_rpc.ResourcesPushRpcApi()
|
|
self.cctxt_mock = self.rpc.client.prepare.return_value
|
|
mock.patch.object(version_manager, 'get_resource_versions',
|
|
return_value=set([TEST_VERSION])).start()
|
|
|
|
def test__prepare_object_fanout_context(self):
|
|
expected_topic = topics.RESOURCE_TOPIC_PATTERN % {
|
|
'resource_type': resources.get_resource_type(
|
|
self.resource_objs[0]),
|
|
'version': TEST_VERSION}
|
|
|
|
observed = self.rpc._prepare_object_fanout_context(
|
|
self.resource_objs[0], self.resource_objs[0].VERSION, '1.0')
|
|
|
|
self.rpc.client.prepare.assert_called_once_with(
|
|
fanout=True, topic=expected_topic, version='1.0')
|
|
self.assertEqual(self.cctxt_mock, observed)
|
|
|
|
def test_push_single_type(self):
|
|
self.rpc.push(
|
|
self.context, self.resource_objs, TEST_EVENT)
|
|
|
|
self.cctxt_mock.cast.assert_called_once_with(
|
|
self.context, 'push',
|
|
resource_list=[resource.obj_to_primitive()
|
|
for resource in self.resource_objs],
|
|
event_type=TEST_EVENT)
|
|
|
|
def test_push_mixed(self):
|
|
self.rpc.push(
|
|
self.context, self.resource_objs + self.resource_objs2,
|
|
event_type=TEST_EVENT)
|
|
|
|
self.cctxt_mock.cast.assert_any_call(
|
|
self.context, 'push',
|
|
resource_list=[resource.obj_to_primitive()
|
|
for resource in self.resource_objs],
|
|
event_type=TEST_EVENT)
|
|
|
|
self.cctxt_mock.cast.assert_any_call(
|
|
self.context, 'push',
|
|
resource_list=[resource.obj_to_primitive()
|
|
for resource in self.resource_objs2],
|
|
event_type=TEST_EVENT)
|
|
|
|
def test_push_mitaka_backwardscompat(self):
|
|
#TODO(mangelajo) remove in Ocata, since the 'resource' parameter
|
|
# is just for backwards compatibility with Mitaka
|
|
# agents.
|
|
self.rpc.push(
|
|
self.context, [self.resource_objs[0]], TEST_EVENT)
|
|
|
|
self.cctxt_mock.cast.assert_called_once_with(
|
|
self.context, 'push',
|
|
resource=self.resource_objs[0].obj_to_primitive(),
|
|
event_type=TEST_EVENT)
|
|
|
|
|
|
class ResourcesPushRpcCallbackTestCase(ResourcesRpcBaseTestCase):
|
|
"""Tests the agent-side of the RPC interface."""
|
|
|
|
def setUp(self):
|
|
super(ResourcesPushRpcCallbackTestCase, self).setUp()
|
|
self.callbacks = resources_rpc.ResourcesPushRpcCallback()
|
|
|
|
@mock.patch.object(resources_rpc.cons_registry, 'push')
|
|
def test_push(self, reg_push_mock):
|
|
self.obj_registry.register(FakeResource)
|
|
self.callbacks.push(self.context,
|
|
resource_list=[resource.obj_to_primitive()
|
|
for resource in self.resource_objs],
|
|
event_type=TEST_EVENT)
|
|
reg_push_mock.assert_called_once_with(self.resource_objs[0].obj_name(),
|
|
self.resource_objs,
|
|
TEST_EVENT)
|
|
|
|
@mock.patch.object(resources_rpc.cons_registry, 'push')
|
|
def test_push_mitaka_backwardscompat(self, reg_push_mock):
|
|
#TODO(mangelajo) remove in Ocata, since the 'resource' parameter
|
|
# is just for backwards compatibility with Mitaka
|
|
# agents.
|
|
self.obj_registry.register(FakeResource)
|
|
self.callbacks.push(self.context,
|
|
resource=self.resource_objs[0].obj_to_primitive(),
|
|
event_type=TEST_EVENT)
|
|
reg_push_mock.assert_called_once_with(self.resource_objs[0].obj_name(),
|
|
[self.resource_objs[0]],
|
|
TEST_EVENT)
|