def __init__(self, host, topic):
serializer = objects_base.IronicObjectSerializer()
super(ConductorManager, self).__init__(host,
topic,
serializer=serializer)
self.power_state_sync_count = collections.defaultdict(int)
def _test_deserialize_entity_newer(self,
obj_version,
backported_to,
mock_indirection_api,
my_version='1.6'):
ser = base.IronicObjectSerializer()
backported_obj = MyObj()
mock_indirection_api.object_backport_versions.return_value \
= backported_obj
@base.IronicObjectRegistry.register
class MyTestObj(MyObj):
VERSION = my_version
obj = MyTestObj(self.context)
obj.VERSION = obj_version
primitive = obj.obj_to_primitive()
result = ser.deserialize_entity(self.context, primitive)
if backported_to is None:
self.assertFalse(
mock_indirection_api.object_backport_versions.called)
else:
self.assertEqual(backported_obj, result)
versions = object_base.obj_tree_get_versions('MyTestObj')
mock_indirection_api.object_backport_versions.assert_called_with(
self.context, primitive, versions)
def start(self):
super(RPCService, self).start()
admin_context = context.get_admin_context()
serializer = objects_base.IronicObjectSerializer(is_server=True)
# Perform preparatory actions before starting the RPC listener
self.manager.prepare_host()
if CONF.rpc_transport == 'json-rpc':
self.rpcserver = json_rpc.WSGIService(
self.manager, serializer, context.RequestContext.from_dict)
else:
target = messaging.Target(topic=self.topic, server=self.host)
endpoints = [self.manager]
self.rpcserver = rpc.get_server(target, endpoints, serializer)
self.rpcserver.start()
self.handle_signal()
self.manager.init_host(admin_context)
LOG.info(
'Created RPC server for service %(service)s on host '
'%(host)s.', {
'service': self.topic,
'host': self.host
})
def test_object_serialization(self):
ser = base.IronicObjectSerializer()
obj = MyObj(self.context)
primitive = ser.serialize_entity(self.context, obj)
self.assertIn('ironic_object.name', primitive)
obj2 = ser.deserialize_entity(self.context, primitive)
self.assertIsInstance(obj2, MyObj)
self.assertEqual(self.context, obj2._context)
def test_serialize_entity_no_pin(self, mock_release_mapping):
CONF.set_override('pin_release_version',
release_mappings.RELEASE_VERSIONS[-1],
enforce_type=True)
mock_release_mapping.__getitem__.return_value = {'objects': {}}
serializer = base.IronicObjectSerializer()
obj = MyObj(self.context)
primitive = serializer.serialize_entity(self.context, obj)
self.assertEqual('1.5', primitive['ironic_object.version'])
def test_object_serialization(self):
ser = base.IronicObjectSerializer()
ctxt = context.get_admin_context()
obj = MyObj()
primitive = ser.serialize_entity(ctxt, obj)
self.assertTrue('ironic_object.name' in primitive)
obj2 = ser.deserialize_entity(ctxt, primitive)
self.assertIsInstance(obj2, MyObj)
self.assertEqual(ctxt, obj2._context)
def test_serialize_entity_invalid_pin(self, mock_version):
mock_version.side_effect = object_exception.InvalidTargetVersion(
version='1.6')
serializer = base.IronicObjectSerializer(is_server=True)
obj = MyObj(self.context)
self.assertRaises(object_exception.InvalidTargetVersion,
serializer.serialize_entity, self.context, obj)
mock_version.assert_called_once_with()
def setUp(self):
super(TestService, self).setUp()
self.config(auth_strategy='noauth', group='json_rpc')
self.server_mock = self.useFixture(
fixtures.MockPatch('oslo_service.wsgi.Server', autospec=True)).mock
self.serializer = objects_base.IronicObjectSerializer(is_server=True)
self.service = server.WSGIService(FakeManager(), self.serializer)
self.app = self.service._application
self.ctx = {'user_name': 'admin'}
def test_serialize_entity_unknown_entity(self, mock_warn, mock_version):
class Foo(object):
fields = {'foobar': fields.IntegerField()}
serializer = base.IronicObjectSerializer()
obj = Foo()
primitive = serializer.serialize_entity(self.context, obj)
self.assertEqual(obj, primitive)
self.assertTrue(mock_warn.called)
mock_version.assert_not_called()
def test__process_object_convert(self, mock_convert):
obj = MyObj(self.context)
obj.foo = 1
obj.bar = 'text'
obj.missing = ''
obj.VERSION = '1.4'
primitive = obj.obj_to_primitive()
serializer = base.IronicObjectSerializer()
serializer._process_object(self.context, primitive)
mock_convert.assert_called_once_with(mock.ANY, '1.5')
def test_serialize_entity_invalid_pin(self, mock_release_mapping):
CONF.set_override('pin_release_version',
release_mappings.RELEASE_VERSIONS[-1])
mock_release_mapping.__getitem__.return_value = {
'objects': {
'MyObj': '1.6',
}
}
serializer = base.IronicObjectSerializer()
obj = MyObj(self.context)
self.assertRaises(object_exception.InvalidTargetVersion,
serializer.serialize_entity, self.context, obj)
def __init__(self, topic=None):
super(ConductorAPI, self).__init__()
self.topic = topic
if self.topic is None:
self.topic = manager.MANAGER_TOPIC
target = messaging.Target(topic=self.topic, version='1.0')
serializer = objects_base.IronicObjectSerializer()
self.client = rpc.get_client(target,
version_cap=self.RPC_API_VERSION,
serializer=serializer)
self.ring_manager = hash.HashRingManager()
def _test__process_object_convert(self, is_server, mock_convert):
obj = MyObj(self.context)
obj.foo = 1
obj.bar = 'text'
obj.missing = ''
obj.VERSION = '1.4'
primitive = obj.obj_to_primitive()
serializer = base.IronicObjectSerializer(is_server=is_server)
serializer._process_object(self.context, primitive)
mock_convert.assert_called_once_with(
mock.ANY, '1.5', remove_unavailable_fields=not is_server)
def test_object_serialization_iterables(self):
ser = base.IronicObjectSerializer()
obj = MyObj(self.context)
for iterable in (list, tuple, set):
thing = iterable([obj])
primitive = ser.serialize_entity(self.context, thing)
self.assertEqual(1, len(primitive))
for item in primitive:
self.assertNotIsInstance(item, base.IronicObject)
thing2 = ser.deserialize_entity(self.context, primitive)
self.assertEqual(1, len(thing2))
for item in thing2:
self.assertIsInstance(item, MyObj)
def __init__(self, topic=None):
if topic is None:
topic = manager.MANAGER_TOPIC
# Initialize consistent hash ring
self.hash_rings = {}
d2c = dbapi.get_instance().get_active_driver_dict()
for driver in d2c.keys():
self.hash_rings[driver] = hash.HashRing(d2c[driver])
super(ConductorAPI, self).__init__(
topic=topic,
serializer=objects_base.IronicObjectSerializer(),
default_version=self.RPC_API_VERSION)
def test_object_serialization_iterables(self):
ser = base.IronicObjectSerializer()
ctxt = context.get_admin_context()
obj = MyObj()
for iterable in (list, tuple, set):
thing = iterable([obj])
primitive = ser.serialize_entity(ctxt, thing)
self.assertEqual(1, len(primitive))
for item in primitive:
self.assertFalse(isinstance(item, base.IronicObject))
thing2 = ser.deserialize_entity(ctxt, primitive)
self.assertEqual(1, len(thing2))
for item in thing2:
self.assertTrue(isinstance(item, MyObj))
def _test__process_object(self, mock_convert, is_server=True):
obj = MyObj(self.context)
obj.foo = 1
obj.bar = 'text'
obj.missing = 'miss'
primitive = obj.obj_to_primitive()
serializer = base.IronicObjectSerializer(is_server=is_server)
obj2 = serializer._process_object(self.context, primitive)
self.assertEqual(obj.foo, obj2.foo)
self.assertEqual(obj.bar, obj2.bar)
self.assertEqual(obj.missing, obj2.missing)
self.assertEqual(obj.VERSION, obj2.VERSION)
self.assertFalse(mock_convert.called)
def start(self):
super(RPCService, self).start()
admin_context = context.RequestContext('admin', 'admin', is_admin=True)
self.tg.add_dynamic_timer(
self.manager.periodic_tasks,
periodic_interval_max=cfg.CONF.periodic_interval,
context=admin_context)
self.manager.init_host()
LOG.debug("Creating RPC server for service %s", self.topic)
target = messaging.Target(topic=self.topic, server=self.host)
endpoints = [self.manager]
serializer = objects_base.IronicObjectSerializer()
self.rpcserver = rpc.get_server(target, endpoints, serializer)
self.rpcserver.start()
def start(self):
super(RPCService, self).start()
admin_context = context.get_admin_context()
target = messaging.Target(topic=self.topic, server=self.host)
endpoints = [self.manager]
serializer = objects_base.IronicObjectSerializer()
self.rpcserver = rpc.get_server(target, endpoints, serializer)
self.rpcserver.start()
self.handle_signal()
self.manager.init_host(admin_context)
LOG.info(_LI('Created RPC server for service %(service)s on host '
'%(host)s.'),
{'service': self.topic, 'host': self.host})
def test_serialize_entity_no_backport(self, make_compatible_mock):
"""Test single element serializer with no backport."""
serializer = base.IronicObjectSerializer()
obj = MyObj(self.context)
obj.foo = 1
obj.bar = 'text'
obj.missing = 'textt'
primitive = serializer.serialize_entity(self.context, obj)
self.assertEqual('1.5', primitive['ironic_object.version'])
data = primitive['ironic_object.data']
self.assertEqual(1, data['foo'])
self.assertEqual('text', data['bar'])
self.assertEqual('textt', data['missing'])
changes = primitive['ironic_object.changes']
self.assertEqual(set(['foo', 'bar', 'missing']), set(changes))
make_compatible_mock.assert_not_called()
def __init__(self, topic=None):
super(ConductorAPI, self).__init__()
self.topic = topic
if self.topic is None:
self.topic = manager.MANAGER_TOPIC
target = messaging.Target(topic=self.topic,
version='1.0')
serializer = objects_base.IronicObjectSerializer()
release_ver = versions.RELEASE_MAPPING.get(CONF.pin_release_version)
version_cap = (release_ver['rpc'] if release_ver
else self.RPC_API_VERSION)
self.client = rpc.get_client(target, version_cap=version_cap,
serializer=serializer)
# NOTE(deva): this is going to be buggy
self.ring_manager = hash_ring.HashRingManager()
def test_serialize_entity_pinned_api(self, mock_version):
"""Test single element serializer with backport to pinned version."""
mock_version.return_value = '1.4'
serializer = base.IronicObjectSerializer(is_server=False)
obj = MyObj(self.context)
obj.foo = 1
obj.bar = 'text'
obj.missing = 'miss'
self.assertEqual('1.5', obj.VERSION)
primitive = serializer.serialize_entity(self.context, obj)
self.assertEqual('1.5', primitive['ironic_object.version'])
data = primitive['ironic_object.data']
self.assertEqual(1, data['foo'])
self.assertEqual('text', data['bar'])
self.assertEqual('miss', data['missing'])
self.assertFalse(mock_version.called)
def test_serialize_entity_unpinned_api(self, mock_version, mock_convert):
"""Test single element serializer with no backport, unpinned."""
mock_version.return_value = MyObj.VERSION
serializer = base.IronicObjectSerializer(is_server=False)
obj = MyObj(self.context)
obj.foo = 1
obj.bar = 'text'
obj.missing = 'textt'
primitive = serializer.serialize_entity(self.context, obj)
self.assertEqual('1.5', primitive['ironic_object.version'])
data = primitive['ironic_object.data']
self.assertEqual(1, data['foo'])
self.assertEqual('text', data['bar'])
self.assertEqual('textt', data['missing'])
changes = primitive['ironic_object.changes']
self.assertEqual(set(['foo', 'bar', 'missing']), set(changes))
self.assertFalse(mock_version.called)
self.assertFalse(mock_convert.called)
def test_serialize_entity_pinned(self, mock_version):
"""Test single element serializer with backport to pinned version."""
mock_version.return_value = '1.4'
serializer = base.IronicObjectSerializer()
obj = MyObj(self.context)
obj.foo = 1
obj.bar = 'text'
obj.missing = 'miss'
self.assertEqual('1.5', obj.VERSION)
primitive = serializer.serialize_entity(self.context, obj)
self.assertEqual('1.4', primitive['ironic_object.version'])
data = primitive['ironic_object.data']
self.assertEqual(1, data['foo'])
self.assertEqual('text', data['bar'])
self.assertEqual('', data['missing'])
changes = primitive['ironic_object.changes']
self.assertEqual(set(['foo', 'bar', 'missing']), set(changes))
mock_version.assert_called_once_with(mock.ANY)
def start(self):
super(RPCService, self).start()
admin_context = context.RequestContext('admin', 'admin', is_admin=True)
target = messaging.Target(topic=self.topic, server=self.host)
endpoints = [self.manager]
serializer = objects_base.IronicObjectSerializer()
self.rpcserver = rpc.get_server(target, endpoints, serializer)
self.rpcserver.start()
self.handle_signal()
self.manager.init_host()
self.tg.add_dynamic_timer(
self.manager.periodic_tasks,
periodic_interval_max=cfg.CONF.periodic_interval,
context=admin_context)
LOG.info(_LI('Created RPC server for service %(service)s on host '
'%(host)s.'),
{'service': self.topic, 'host': self.host})
def test_deserialize_entity_pin_ignored(self, mock_release_mapping):
# Deserializing doesn't look at pinning
CONF.set_override('pin_release_version',
release_mappings.RELEASE_VERSIONS[-1])
mock_release_mapping.__getitem__.return_value = {
'objects': {
'MyTestObj': ['1.0'],
}
}
ser = base.IronicObjectSerializer()
@base.IronicObjectRegistry.register
class MyTestObj(MyObj):
VERSION = '1.1'
obj = MyTestObj(self.context)
primitive = obj.obj_to_primitive()
result = ser.deserialize_entity(self.context, primitive)
self.assertEqual('1.1', result.VERSION)
self.assertEqual('1.0', result.get_target_version())
self.assertFalse(mock_release_mapping.called)
def test_serialize_entity_backport(self, mock_release_mapping):
"""Test single element serializer with backport."""
CONF.set_override('pin_release_version',
release_mappings.RELEASE_VERSIONS[-1])
mock_release_mapping.__getitem__.return_value = {
'objects': {
'MyObj': '1.4',
}
}
serializer = base.IronicObjectSerializer()
obj = MyObj(self.context)
obj.foo = 1
obj.bar = 'text'
obj.missing = 'textt'
primitive = serializer.serialize_entity(self.context, obj)
self.assertEqual('1.4', primitive['ironic_object.version'])
data = primitive['ironic_object.data']
self.assertEqual(1, data['foo'])
self.assertEqual('text', data['bar'])
self.assertNotIn('missing', data)
changes = primitive['ironic_object.changes']
self.assertEqual(set(['foo', 'bar']), set(changes))
def __init__(self, host, topic):
serializer = objects_base.IronicObjectSerializer()
super(ConductorManager, self).__init__(host,
topic,
serializer=serializer)
def setUp(self):
super(TestClient, self).setUp()
self.serializer = objects_base.IronicObjectSerializer(is_server=True)
self.client = client.Client(self.serializer)
self.ctx_json = self.context.to_dict()
def test_deserialize_entity_primitive(self):
ser = base.IronicObjectSerializer()
for thing in (1, 'foo', [1, 2], {'foo': 'bar'}):
self.assertEqual(thing, ser.deserialize_entity(None, thing))
