372 lines
15 KiB
Python
372 lines
15 KiB
Python
# 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 collections
|
|
|
|
import mock
|
|
from oslo_utils import timeutils
|
|
from oslo_versionedobjects import fixture
|
|
|
|
from nova.network import model as network_model
|
|
from nova.notifications import base as notification_base
|
|
from nova.notifications.objects import base as notification
|
|
from nova import objects
|
|
from nova.objects import base
|
|
from nova.objects import fields
|
|
from nova import test
|
|
from nova.tests.unit.objects import test_objects
|
|
|
|
|
|
class TestNotificationBase(test.NoDBTestCase):
|
|
|
|
@base.NovaObjectRegistry.register_if(False)
|
|
class TestObject(base.NovaObject):
|
|
VERSION = '1.0'
|
|
fields = {
|
|
'field_1': fields.StringField(),
|
|
'field_2': fields.IntegerField(),
|
|
'not_important_field': fields.IntegerField(),
|
|
}
|
|
|
|
@base.NovaObjectRegistry.register_if(False)
|
|
class TestNotificationPayload(notification.NotificationPayloadBase):
|
|
VERSION = '1.0'
|
|
|
|
SCHEMA = {
|
|
'field_1': ('source_field', 'field_1'),
|
|
'field_2': ('source_field', 'field_2'),
|
|
}
|
|
|
|
fields = {
|
|
'extra_field': fields.StringField(), # filled by ctor
|
|
'field_1': fields.StringField(), # filled by the schema
|
|
'field_2': fields.IntegerField(), # filled by the schema
|
|
}
|
|
|
|
def populate_schema(self, source_field):
|
|
super(TestNotificationBase.TestNotificationPayload,
|
|
self).populate_schema(source_field=source_field)
|
|
|
|
@base.NovaObjectRegistry.register_if(False)
|
|
class TestNotificationPayloadEmptySchema(
|
|
notification.NotificationPayloadBase):
|
|
VERSION = '1.0'
|
|
|
|
fields = {
|
|
'extra_field': fields.StringField(), # filled by ctor
|
|
}
|
|
|
|
@notification.notification_sample('test-update-1.json')
|
|
@notification.notification_sample('test-update-2.json')
|
|
@base.NovaObjectRegistry.register_if(False)
|
|
class TestNotification(notification.NotificationBase):
|
|
VERSION = '1.0'
|
|
fields = {
|
|
'payload': fields.ObjectField('TestNotificationPayload')
|
|
}
|
|
|
|
@base.NovaObjectRegistry.register_if(False)
|
|
class TestNotificationEmptySchema(notification.NotificationBase):
|
|
VERSION = '1.0'
|
|
fields = {
|
|
'payload': fields.ObjectField('TestNotificationPayloadEmptySchema')
|
|
}
|
|
|
|
fake_service = {
|
|
'created_at': timeutils.utcnow().replace(microsecond=0),
|
|
'updated_at': None,
|
|
'deleted_at': None,
|
|
'deleted': False,
|
|
'id': 123,
|
|
'host': 'fake-host',
|
|
'binary': 'nova-fake',
|
|
'topic': 'fake-service-topic',
|
|
'report_count': 1,
|
|
'forced_down': False,
|
|
'disabled': False,
|
|
'disabled_reason': None,
|
|
'last_seen_up': None,
|
|
'version': 1}
|
|
|
|
expected_payload = {
|
|
'nova_object.name': 'TestNotificationPayload',
|
|
'nova_object.data': {
|
|
'extra_field': 'test string',
|
|
'field_1': 'test1',
|
|
'field_2': 42},
|
|
'nova_object.version': '1.0',
|
|
'nova_object.namespace': 'nova'}
|
|
|
|
def setUp(self):
|
|
super(TestNotificationBase, self).setUp()
|
|
with mock.patch('nova.db.service_update') as mock_db_service_update:
|
|
self.service_obj = objects.Service(context=mock.sentinel.context,
|
|
id=self.fake_service['id'])
|
|
self.service_obj.obj_reset_changes(['version'])
|
|
mock_db_service_update.return_value = self.fake_service
|
|
self.service_obj.save()
|
|
|
|
self.my_obj = self.TestObject(field_1='test1',
|
|
field_2=42,
|
|
not_important_field=13)
|
|
|
|
self.payload = self.TestNotificationPayload(
|
|
extra_field='test string')
|
|
self.payload.populate_schema(source_field=self.my_obj)
|
|
|
|
self.notification = self.TestNotification(
|
|
event_type=notification.EventType(
|
|
object='test_object',
|
|
action=fields.NotificationAction.UPDATE,
|
|
phase=fields.NotificationPhase.START),
|
|
publisher=notification.NotificationPublisher.from_service_obj(
|
|
self.service_obj),
|
|
priority=fields.NotificationPriority.INFO,
|
|
payload=self.payload)
|
|
|
|
def _verify_notification(self, mock_notifier, mock_context,
|
|
expected_event_type,
|
|
expected_payload):
|
|
mock_notifier.prepare.assert_called_once_with(
|
|
publisher_id='nova-fake:fake-host')
|
|
mock_notify = mock_notifier.prepare.return_value.info
|
|
self.assertTrue(mock_notify.called)
|
|
self.assertEqual(mock_notify.call_args[0][0], mock_context)
|
|
self.assertEqual(mock_notify.call_args[1]['event_type'],
|
|
expected_event_type)
|
|
actual_payload = mock_notify.call_args[1]['payload']
|
|
self.assertJsonEqual(expected_payload, actual_payload)
|
|
|
|
@mock.patch('nova.rpc.LEGACY_NOTIFIER')
|
|
@mock.patch('nova.rpc.NOTIFIER')
|
|
def test_emit_notification(self, mock_notifier, mock_legacy):
|
|
|
|
mock_context = mock.Mock()
|
|
mock_context.to_dict.return_value = {}
|
|
self.notification.emit(mock_context)
|
|
|
|
self._verify_notification(
|
|
mock_notifier,
|
|
mock_context,
|
|
expected_event_type='test_object.update.start',
|
|
expected_payload=self.expected_payload)
|
|
self.assertFalse(mock_legacy.called)
|
|
|
|
@mock.patch('nova.rpc.NOTIFIER')
|
|
def test_emit_with_host_and_binary_as_publisher(self, mock_notifier):
|
|
noti = self.TestNotification(
|
|
event_type=notification.EventType(
|
|
object='test_object',
|
|
action=fields.NotificationAction.UPDATE),
|
|
publisher=notification.NotificationPublisher(host='fake-host',
|
|
binary='nova-fake'),
|
|
priority=fields.NotificationPriority.INFO,
|
|
payload=self.payload)
|
|
|
|
mock_context = mock.Mock()
|
|
mock_context.to_dict.return_value = {}
|
|
noti.emit(mock_context)
|
|
|
|
self._verify_notification(
|
|
mock_notifier,
|
|
mock_context,
|
|
expected_event_type='test_object.update',
|
|
expected_payload=self.expected_payload)
|
|
|
|
@mock.patch('nova.rpc.LEGACY_NOTIFIER')
|
|
@mock.patch('nova.rpc.NOTIFIER')
|
|
def test_emit_event_type_without_phase(self, mock_notifier, mock_legacy):
|
|
noti = self.TestNotification(
|
|
event_type=notification.EventType(
|
|
object='test_object',
|
|
action=fields.NotificationAction.UPDATE),
|
|
publisher=notification.NotificationPublisher.from_service_obj(
|
|
self.service_obj),
|
|
priority=fields.NotificationPriority.INFO,
|
|
payload=self.payload)
|
|
|
|
mock_context = mock.Mock()
|
|
mock_context.to_dict.return_value = {}
|
|
noti.emit(mock_context)
|
|
|
|
self._verify_notification(
|
|
mock_notifier,
|
|
mock_context,
|
|
expected_event_type='test_object.update',
|
|
expected_payload=self.expected_payload)
|
|
self.assertFalse(mock_legacy.called)
|
|
|
|
@mock.patch('nova.rpc.NOTIFIER')
|
|
def test_not_possible_to_emit_if_not_populated(self, mock_notifier):
|
|
non_populated_payload = self.TestNotificationPayload(
|
|
extra_field='test string')
|
|
noti = self.TestNotification(
|
|
event_type=notification.EventType(
|
|
object='test_object',
|
|
action=fields.NotificationAction.UPDATE),
|
|
publisher=notification.NotificationPublisher.from_service_obj(
|
|
self.service_obj),
|
|
priority=fields.NotificationPriority.INFO,
|
|
payload=non_populated_payload)
|
|
|
|
mock_context = mock.Mock()
|
|
self.assertRaises(AssertionError, noti.emit, mock_context)
|
|
self.assertFalse(mock_notifier.called)
|
|
|
|
@mock.patch('nova.rpc.NOTIFIER')
|
|
def test_empty_schema(self, mock_notifier):
|
|
non_populated_payload = self.TestNotificationPayloadEmptySchema(
|
|
extra_field='test string')
|
|
noti = self.TestNotificationEmptySchema(
|
|
event_type=notification.EventType(
|
|
object='test_object',
|
|
action=fields.NotificationAction.UPDATE),
|
|
publisher=notification.NotificationPublisher.from_service_obj(
|
|
self.service_obj),
|
|
priority=fields.NotificationPriority.INFO,
|
|
payload=non_populated_payload)
|
|
|
|
mock_context = mock.Mock()
|
|
mock_context.to_dict.return_value = {}
|
|
noti.emit(mock_context)
|
|
|
|
self._verify_notification(
|
|
mock_notifier,
|
|
mock_context,
|
|
expected_event_type='test_object.update',
|
|
expected_payload=
|
|
{'nova_object.name': 'TestNotificationPayloadEmptySchema',
|
|
'nova_object.data': {'extra_field': u'test string'},
|
|
'nova_object.version': '1.0',
|
|
'nova_object.namespace': 'nova'})
|
|
|
|
def test_sample_decorator(self):
|
|
self.assertEqual(2, len(self.TestNotification.samples))
|
|
self.assertIn('test-update-1.json', self.TestNotification.samples)
|
|
self.assertIn('test-update-2.json', self.TestNotification.samples)
|
|
|
|
|
|
notification_object_data = {
|
|
'AggregateNotification': '1.0-a73147b93b520ff0061865849d3dfa56',
|
|
'AggregatePayload': '1.0-2550af604410af7b4ad5d46fb29ba45b',
|
|
'AuditPeriodPayload': '1.0-2b429dd307b8374636703b843fa3f9cb',
|
|
'BandwidthPayload': '1.0-ee2616a7690ab78406842a2b68e34130',
|
|
'EventType': '1.4-da0f0fbcda143ca96c2ac1b93937c22c',
|
|
'ExceptionNotification': '1.0-a73147b93b520ff0061865849d3dfa56',
|
|
'ExceptionPayload': '1.0-27db46ee34cd97e39f2643ed92ad0cc5',
|
|
'FlavorPayload': '1.0-89b17e778291bba22025b5956e072b66',
|
|
'InstanceActionNotification': '1.0-a73147b93b520ff0061865849d3dfa56',
|
|
'InstanceActionPayload': '1.1-8d12efc3251c606b61b3d479a9da51be',
|
|
'InstanceActionVolumeSwapNotification':
|
|
'1.0-a73147b93b520ff0061865849d3dfa56',
|
|
'InstanceActionVolumeSwapPayload': '1.1-fbb6618f652a7f88742495ea3185582c',
|
|
'InstancePayload': '1.1-5b9e3a4bb805d9fed20063bc237e4913',
|
|
'InstanceStateUpdatePayload': '1.0-07e111c0fa0f6db0f79b0726d593e3da',
|
|
'InstanceUpdateNotification': '1.0-a73147b93b520ff0061865849d3dfa56',
|
|
'InstanceUpdatePayload': '1.1-12955de638c3a4bcd734601711214d39',
|
|
'IpPayload': '1.0-8ecf567a99e516d4af094439a7632d34',
|
|
'NotificationPublisher': '1.0-bbbc1402fb0e443a3eb227cc52b61545',
|
|
'ServiceStatusNotification': '1.0-a73147b93b520ff0061865849d3dfa56',
|
|
'ServiceStatusPayload': '1.0-c43a812046139e875ff2dc5590cd8d02',
|
|
}
|
|
|
|
|
|
class TestNotificationObjectVersions(test.NoDBTestCase):
|
|
def setUp(self):
|
|
super(test.NoDBTestCase, self).setUp()
|
|
base.NovaObjectRegistry.register_notification_objects()
|
|
|
|
def test_versions(self):
|
|
checker = fixture.ObjectVersionChecker(
|
|
test_objects.get_nova_objects())
|
|
notification_object_data.update(test_objects.object_data)
|
|
expected, actual = checker.test_hashes(notification_object_data,
|
|
extra_data_func=get_extra_data)
|
|
self.assertEqual(expected, actual,
|
|
'Some notification objects have changed; please make '
|
|
'sure the versions have been bumped, and then update '
|
|
'their hashes here.')
|
|
|
|
def test_notification_payload_version_depends_on_the_schema(self):
|
|
@base.NovaObjectRegistry.register_if(False)
|
|
class TestNotificationPayload(notification.NotificationPayloadBase):
|
|
VERSION = '1.0'
|
|
|
|
SCHEMA = {
|
|
'field_1': ('source_field', 'field_1'),
|
|
'field_2': ('source_field', 'field_2'),
|
|
}
|
|
|
|
fields = {
|
|
'extra_field': fields.StringField(), # filled by ctor
|
|
'field_1': fields.StringField(), # filled by the schema
|
|
'field_2': fields.IntegerField(), # filled by the schema
|
|
}
|
|
|
|
checker = fixture.ObjectVersionChecker(
|
|
{'TestNotificationPayload': (TestNotificationPayload,)})
|
|
|
|
old_hash = checker.get_hashes(extra_data_func=get_extra_data)
|
|
TestNotificationPayload.SCHEMA['field_3'] = ('source_field',
|
|
'field_3')
|
|
new_hash = checker.get_hashes(extra_data_func=get_extra_data)
|
|
|
|
self.assertNotEqual(old_hash, new_hash)
|
|
|
|
|
|
def get_extra_data(obj_class):
|
|
extra_data = tuple()
|
|
|
|
# Get the SCHEMA items to add to the fingerprint
|
|
# if we are looking at a notification
|
|
if issubclass(obj_class, notification.NotificationPayloadBase):
|
|
schema_data = collections.OrderedDict(
|
|
sorted(obj_class.SCHEMA.items()))
|
|
|
|
extra_data += (schema_data,)
|
|
|
|
return extra_data
|
|
|
|
|
|
class TestInstanceNotification(test.NoDBTestCase):
|
|
@mock.patch('nova.notifications.objects.instance.'
|
|
'InstanceUpdateNotification._emit')
|
|
def test_send_version_instance_update_uses_flavor(self, mock_emit):
|
|
# Make sure that the notification payload chooses the values in
|
|
# instance.flavor.$value instead of instance.$value
|
|
test_keys = ['memory_mb', 'vcpus', 'root_gb', 'ephemeral_gb']
|
|
flavor_values = {k: 123 for k in test_keys}
|
|
instance_values = {k: 456 for k in test_keys}
|
|
flavor = objects.Flavor(**flavor_values)
|
|
info_cache = objects.InstanceInfoCache(
|
|
network_info=network_model.NetworkInfo())
|
|
instance = objects.Instance(
|
|
flavor=flavor,
|
|
info_cache=info_cache,
|
|
**instance_values)
|
|
payload = {
|
|
'bandwidth': {},
|
|
'audit_period_ending': timeutils.utcnow(),
|
|
'audit_period_beginning': timeutils.utcnow(),
|
|
}
|
|
notification_base._send_versioned_instance_update(
|
|
mock.MagicMock(),
|
|
instance,
|
|
payload,
|
|
'host',
|
|
'compute')
|
|
payload = mock_emit.call_args_list[0][1]['payload']['nova_object.data']
|
|
flavor_payload = payload['flavor']['nova_object.data']
|
|
data = {k: flavor_payload[k] for k in test_keys}
|
|
self.assertEqual(flavor_values, data)
|