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))