def start(self): version_string = version.version_string() LOG.info(_LI('Starting %(topic)s node (version %(version_string)s)'), { 'topic': self.topic, 'version_string': version_string }) self.model_disconnected = False if self.coordination: coordination.COORDINATOR.start() self.manager.init_host(added_to_cluster=self.added_to_cluster) LOG.debug("Creating RPC server for service %s", self.topic) ctxt = context.get_admin_context() target = messaging.Target(topic=self.topic, server=self.host) endpoints = [self.manager] endpoints.extend(self.manager.additional_endpoints) obj_version_cap = objects.Service.get_minimum_obj_version(ctxt) LOG.debug("Pinning object versions for RPC server serializer to %s", obj_version_cap) serializer = objects_base.CinderObjectSerializer(obj_version_cap) self.rpcserver = rpc.get_server(target, endpoints, serializer) self.rpcserver.start() # TODO(geguileo): In O - Remove the is_svc_upgrading_to_n part if self.cluster and not self.is_svc_upgrading_to_n(self.binary): LOG.info( _LI('Starting %(topic)s cluster %(cluster)s (version ' '%(version)s)'), { 'topic': self.topic, 'version': version_string, 'cluster': self.cluster }) target = messaging.Target(topic=self.topic, server=self.cluster) serializer = objects_base.CinderObjectSerializer(obj_version_cap) self.cluster_rpcserver = rpc.get_server(target, endpoints, serializer) self.cluster_rpcserver.start() self.manager.init_host_with_rpc() if self.report_interval: pulse = loopingcall.FixedIntervalLoopingCall(self.report_state) pulse.start(interval=self.report_interval, initial_delay=self.report_interval) self.timers.append(pulse) if self.periodic_interval: if self.periodic_fuzzy_delay: initial_delay = random.randint(0, self.periodic_fuzzy_delay) else: initial_delay = None periodic = loopingcall.FixedIntervalLoopingCall( self.periodic_tasks) periodic.start(interval=self.periodic_interval, initial_delay=initial_delay) self.timers.append(periodic)
def __init__(self): super(SchedulerAPI, self).__init__() target = messaging.Target(topic=CONF.scheduler_topic, version=self.RPC_API_VERSION) serializer = objects_base.CinderObjectSerializer() self.client = rpc.get_client(target, version_cap='1.9', serializer=serializer)
def test_object_serialization_iterables(self): ser = base.CinderObjectSerializer() obj = MyObj() 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.CinderObject) thing2 = ser.deserialize_entity(self.context, primitive) self.assertEqual(1, len(thing2)) for item in thing2: self.assertIsInstance(item, MyObj) # dict case thing = {'key': obj} primitive = ser.serialize_entity(self.context, thing) self.assertEqual(1, len(primitive)) for item in primitive.itervalues(): self.assertNotIsInstance(item, base.CinderObject) thing2 = ser.deserialize_entity(self.context, primitive) self.assertEqual(1, len(thing2)) for item in thing2.itervalues(): self.assertIsInstance(item, MyObj) # object-action updates dict case thing = {'foo': obj.obj_to_primitive()} primitive = ser.serialize_entity(self.context, thing) self.assertEqual(thing, primitive) thing2 = ser.deserialize_entity(self.context, thing) self.assertIsInstance(thing2['foo'], base.CinderObject)
def __init__(self): super(BackupAPI, self).__init__() target = messaging.Target(topic=CONF.backup_topic, version=self.BASE_RPC_API_VERSION) serializer = objects_base.CinderObjectSerializer() self.client = rpc.get_client(target, self.RPC_API_VERSION, serializer=serializer)
def test_object_serialization(self): ser = base.CinderObjectSerializer() obj = MyObj() primitive = ser.serialize_entity(self.context, obj) self.assertIn('cinder_object.name', primitive) obj2 = ser.deserialize_entity(self.context, primitive) self.assertIsInstance(obj2, MyObj) self.assertEqual(self.context, obj2._context)
def rpc_client(self): if self._client is None: if not rpc.initialized(): rpc.init(CONF) target = messaging.Target(topic=CONF.volume_topic) serializer = objects_base.CinderObjectSerializer() self._client = rpc.get_client(target, serializer=serializer) return self._client
def test_obj_make_compatible_use_quota_added(self, version): snapshot = objects.Snapshot(self.context, use_quota=False) serializer = ovo_base.CinderObjectSerializer(version) primitive = serializer.serialize_entity(self.context, snapshot) converted_snapshot = objects.Snapshot.obj_from_primitive(primitive) expected = version != '1.39' self.assertIs(expected, converted_snapshot.use_quota)
def __init__(self): target = messaging.Target(topic=self.TOPIC, version=self.RPC_API_VERSION) obj_version_cap = self.determine_obj_version_cap() serializer = base.CinderObjectSerializer(obj_version_cap) rpc_version_cap = self.determine_rpc_version_cap() self.client = get_client(target, version_cap=rpc_version_cap, serializer=serializer)
def __init__(self, topic=None): super(VolumeAPI, self).__init__() target = messaging.Target(topic=CONF.volume_topic, version=self.BASE_RPC_API_VERSION) serializer = objects_base.CinderObjectSerializer() # NOTE(thangp): Until version pinning is impletemented, set the client # version_cap to None self.client = rpc.get_client(target, version_cap=None, serializer=serializer)
def test_obj_make_compatible_use_quota_added(self, version, ovo, expected): volume = objects.Volume(self.context, **ovo) # When serializing to v1.38 we'll lose the use_quota value so it will # be recalculated based on the Volume values serializer = ovo_base.CinderObjectSerializer(version) primitive = serializer.serialize_entity(self.context, volume) converted_volume = objects.Volume.obj_from_primitive(primitive) self.assertIs(expected, converted_volume.use_quota)
def test_obj_make_compatible_groups_added(self, version): extra_data = {'group_id': fake.GROUP_ID, 'group': objects.Group()} volume = objects.Volume(self.context, host='host', **extra_data) serializer = ovo_base.CinderObjectSerializer(version) primitive = serializer.serialize_entity(self.context, volume) converted_volume = objects.Volume.obj_from_primitive(primitive) is_set = version == '1.10' for key in extra_data: self.assertEqual(is_set, converted_volume.obj_attr_is_set(key)) self.assertEqual('host', converted_volume.host)
def test_obj_make_compatible_cluster_added(self, version): extra_data = {'cluster_name': 'cluster_name', 'cluster': objects.Cluster()} volume = objects.Volume(self.context, host='host', **extra_data) serializer = ovo_base.CinderObjectSerializer(version) primitive = serializer.serialize_entity(self.context, volume) converted_volume = objects.Volume.obj_from_primitive(primitive) is_set = version == '1.7' for key in extra_data: self.assertEqual(is_set, converted_volume.obj_attr_is_set(key)) self.assertEqual('host', converted_volume.host)
def test_obj_make_compatible(self, version): extra_data = {'group_snapshot_id': fake.GROUP_SNAPSHOT_ID, 'source_group_id': fake.GROUP_ID, 'group_snapshots': objects.GroupSnapshotList()} group = objects.Group(self.context, name='name', **extra_data) serializer = ovo_base.CinderObjectSerializer(version) primitive = serializer.serialize_entity(self.context, group) converted_group = objects.Group.obj_from_primitive(primitive) is_set = version == '1.11' for key in extra_data: self.assertEqual(is_set, converted_group.obj_attr_is_set(key)) self.assertEqual('name', converted_group.name)
def start(self): version_string = version.version_string() LOG.info(_LI('Starting %(topic)s node (version %(version_string)s)'), { 'topic': self.topic, 'version_string': version_string }) self.model_disconnected = False self.manager.init_host() ctxt = context.get_admin_context() try: service_ref = objects.Service.get_by_args(ctxt, self.host, self.binary) service_ref.rpc_current_version = self.manager.RPC_API_VERSION obj_version = objects_base.OBJ_VERSIONS.get_current() service_ref.object_current_version = obj_version service_ref.save() self.service_id = service_ref.id except exception.NotFound: self._create_service_ref(ctxt) LOG.debug("Creating RPC server for service %s", self.topic) target = messaging.Target(topic=self.topic, server=self.host) endpoints = [self.manager] endpoints.extend(self.manager.additional_endpoints) serializer = objects_base.CinderObjectSerializer() self.rpcserver = rpc.get_server(target, endpoints, serializer) self.rpcserver.start() self.manager.init_host_with_rpc() if self.report_interval: pulse = loopingcall.FixedIntervalLoopingCall(self.report_state) pulse.start(interval=self.report_interval, initial_delay=self.report_interval) self.timers.append(pulse) if self.periodic_interval: if self.periodic_fuzzy_delay: initial_delay = random.randint(0, self.periodic_fuzzy_delay) else: initial_delay = None periodic = loopingcall.FixedIntervalLoopingCall( self.periodic_tasks) periodic.start(interval=self.periodic_interval, initial_delay=initial_delay) self.timers.append(periodic)
def _test_deserialize_entity_newer(self, obj_version, backported_to, my_version='1.6'): ser = base.CinderObjectSerializer() ser._conductor = mock.Mock() ser._conductor.object_backport.return_value = 'backported' class MyTestObj(MyObj): VERSION = my_version obj = MyTestObj() obj.VERSION = obj_version primitive = obj.obj_to_primitive() ser.deserialize_entity(self.context, primitive) if backported_to is None: self.assertFalse(ser._conductor.object_backport.called)
def test_deserialize_dot_z_with_extra_stuff(self): primitive = { 'cinder_object.name': 'MyObj', 'cinder_object.namespace': 'cinder', 'cinder_object.version': '1.6.1', 'cinder_object.data': { 'foo': 1, 'unexpected_thing': 'foobar' } } ser = base.CinderObjectSerializer() obj = ser.deserialize_entity(self.context, primitive) self.assertEqual(1, obj.foo) self.assertFalse(hasattr(obj, 'unexpected_thing')) # NOTE(danms): The serializer is where the logic lives that # avoids backports for cases where only a .z difference in # the received object version is detected. As a result, we # end up with a version of what we expected, effectively the # .0 of the object. self.assertEqual('1.6', obj.VERSION)
def start(self): version_string = version.version_string() LOG.info(_LI('Starting %(topic)s node (version %(version_string)s)'), { 'topic': self.topic, 'version_string': version_string }) self.model_disconnected = False if self.coordination: coordination.COORDINATOR.start() 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] endpoints.extend(self.manager.additional_endpoints) serializer = objects_base.CinderObjectSerializer() self.rpcserver = rpc.get_server(target, endpoints, serializer) self.rpcserver.start() self.manager.init_host_with_rpc() if self.report_interval: pulse = loopingcall.FixedIntervalLoopingCall(self.report_state) pulse.start(interval=self.report_interval, initial_delay=self.report_interval) self.timers.append(pulse) if self.periodic_interval: if self.periodic_fuzzy_delay: initial_delay = random.randint(0, self.periodic_fuzzy_delay) else: initial_delay = None periodic = loopingcall.FixedIntervalLoopingCall( self.periodic_tasks) periodic.start(interval=self.periodic_interval, initial_delay=initial_delay) self.timers.append(periodic)
def start(self): version_string = version.version_string() LOG.info('Starting %(topic)s node (version %(version_string)s)', { 'topic': self.topic, 'version_string': version_string }) self.model_disconnected = False if self.coordination: coordination.COORDINATOR.start() # NOTE(yikun): When re-spawning child process, we should set the class # attribute back using the origin service_id, otherwise, # the Service.service_id will be inherited from the parent process, # and will be recorded as the last started service id by mistaken. Service.service_id = self.origin_service_id self.manager.init_host(added_to_cluster=self.added_to_cluster, service_id=Service.service_id) LOG.debug("Creating RPC server for service %s", self.topic) ctxt = context.get_admin_context() endpoints = [self.manager] endpoints.extend(self.manager.additional_endpoints) obj_version_cap = objects.Service.get_minimum_obj_version(ctxt) LOG.debug("Pinning object versions for RPC server serializer to %s", obj_version_cap) serializer = objects_base.CinderObjectSerializer(obj_version_cap) target = messaging.Target(topic=self.topic, server=self.host) self.rpcserver = rpc.get_server(target, endpoints, serializer) self.rpcserver.start() # NOTE(dulek): Kids, don't do that at home. We're relying here on # oslo.messaging implementation details to keep backward compatibility # with pre-Ocata services. This will not matter once we drop # compatibility with them. if self.topic == constants.VOLUME_TOPIC: target = messaging.Target(topic='%(topic)s.%(host)s' % { 'topic': self.topic, 'host': self.host }, server=volume_utils.extract_host( self.host, 'host')) self.backend_rpcserver = rpc.get_server(target, endpoints, serializer) self.backend_rpcserver.start() if self.cluster: LOG.info( 'Starting %(topic)s cluster %(cluster)s (version ' '%(version)s)', { 'topic': self.topic, 'version': version_string, 'cluster': self.cluster }) target = messaging.Target( topic='%s.%s' % (self.topic, self.cluster), server=volume_utils.extract_host(self.cluster, 'host')) serializer = objects_base.CinderObjectSerializer(obj_version_cap) self.cluster_rpcserver = rpc.get_server(target, endpoints, serializer) self.cluster_rpcserver.start() self.manager.init_host_with_rpc() if self.report_interval: self.tg.add_timer(self.report_interval, self.report_state, initial_delay=self.report_interval) if self.periodic_interval: if self.periodic_fuzzy_delay: initial_delay = random.randint(0, self.periodic_fuzzy_delay) else: initial_delay = None self.tg.add_timer(self.periodic_interval, self.periodic_tasks, initial_delay=initial_delay)
def test_deserialize_entity_primitive(self): ser = base.CinderObjectSerializer() for thing in (1, 'foo', [1, 2], {'foo': 'bar'}): self.assertEqual(thing, ser.deserialize_entity(None, thing))
def start(self): version_string = version.version_string() LOG.info('Starting %(topic)s node (version %(version_string)s)', { 'topic': self.topic, 'version_string': version_string }) self.model_disconnected = False if self.coordination: coordination.COORDINATOR.start() self.manager.init_host(added_to_cluster=self.added_to_cluster, service_id=Service.service_id) LOG.debug("Creating RPC server for service %s", self.topic) ctxt = context.get_admin_context() endpoints = [self.manager] endpoints.extend(self.manager.additional_endpoints) obj_version_cap = objects.Service.get_minimum_obj_version(ctxt) LOG.debug("Pinning object versions for RPC server serializer to %s", obj_version_cap) serializer = objects_base.CinderObjectSerializer(obj_version_cap) target = messaging.Target(topic=self.topic, server=self.host) self.rpcserver = rpc.get_server(target, endpoints, serializer) self.rpcserver.start() # NOTE(dulek): Kids, don't do that at home. We're relying here on # oslo.messaging implementation details to keep backward compatibility # with pre-Ocata services. This will not matter once we drop # compatibility with them. if self.topic == constants.VOLUME_TOPIC: target = messaging.Target(topic='%(topic)s.%(host)s' % { 'topic': self.topic, 'host': self.host }, server=vol_utils.extract_host( self.host, 'host')) self.backend_rpcserver = rpc.get_server(target, endpoints, serializer) self.backend_rpcserver.start() # TODO(geguileo): In O - Remove the is_svc_upgrading_to_n part if self.cluster and not self.is_svc_upgrading_to_n(self.binary): LOG.info( 'Starting %(topic)s cluster %(cluster)s (version ' '%(version)s)', { 'topic': self.topic, 'version': version_string, 'cluster': self.cluster }) target = messaging.Target( topic='%s.%s' % (self.topic, self.cluster), server=vol_utils.extract_host(self.cluster, 'host')) serializer = objects_base.CinderObjectSerializer(obj_version_cap) self.cluster_rpcserver = rpc.get_server(target, endpoints, serializer) self.cluster_rpcserver.start() self.manager.init_host_with_rpc() if self.report_interval: pulse = loopingcall.FixedIntervalLoopingCall(self.report_state) pulse.start(interval=self.report_interval, initial_delay=self.report_interval) self.timers.append(pulse) if self.periodic_interval: if self.periodic_fuzzy_delay: initial_delay = random.randint(0, self.periodic_fuzzy_delay) else: initial_delay = None periodic = loopingcall.FixedIntervalLoopingCall( self.periodic_tasks) periodic.start(interval=self.periodic_interval, initial_delay=initial_delay) self.timers.append(periodic)
def __init__(self, topic=None): super(VolumeAPI, self).__init__() target = messaging.Target(topic=CONF.volume_topic, version=self.BASE_RPC_API_VERSION) serializer = objects_base.CinderObjectSerializer() self.client = rpc.get_client(target, '1.24', serializer=serializer)