def __init__( self, portable_context, factory_id=None, class_id=None, version=None, class_def_builder=None ): self.portable_context = portable_context if class_def_builder is None: self._builder = ClassDefinitionBuilder(factory_id, class_id, version) else: self._builder = class_def_builder
def read_class_definition(self, data_in, factory_id, class_id, version): register = True builder = ClassDefinitionBuilder(factory_id, class_id, version) # final position after portable is read data_in.read_int() # field count field_count = data_in.read_int() offset = data_in.position() for i in range(0, field_count): pos = data_in.read_int(offset + i * bits.INT_SIZE_IN_BYTES) data_in.set_position(pos) _len = data_in.read_short() field_name = bytearray(_len) data_in.read_into(field_name) field_type = data_in.read_byte() field_factory_id = 0 field_class_id = 0 field_version = version if field_type == FieldType.PORTABLE: # is null if data_in.read_boolean(): register = False field_factory_id = data_in.read_int() field_class_id = data_in.read_int() # TODO: what there's a null inner Portable field if register: field_version = data_in.read_int() self.read_class_definition(data_in, field_factory_id, field_class_id, field_version) elif field_type == FieldType.PORTABLE_ARRAY: k = data_in.read_int() field_factory_id = data_in.read_int() field_class_id = data_in.read_int() # TODO: what there's a null inner Portable field if k > 0: p = data_in.read_int() data_in.set_position(p) field_version = data_in.read_int() self.read_class_definition(data_in, field_factory_id, field_class_id, field_version) else: register = False builder.add_field_def( FieldDefinition(i, field_name.decode('ascii'), field_type, field_version, field_factory_id, field_class_id)) class_def = builder.build() if register: class_def = self.register_class_definition(class_def) return class_def
def test_duplicate_class_definition(self): config = _Config() class_def1 = ClassDefinitionBuilder(1, 1).add_string_field("str_field").build() class_def2 = ClassDefinitionBuilder(1, 1).add_int_field("int_field").build() config.class_definitions = [class_def1, class_def2] with self.assertRaises(HazelcastSerializationError): SerializationServiceV1(config)
def read_class_definition(self, data_in, factory_id, class_id, version): register = True builder = ClassDefinitionBuilder(factory_id, class_id, version) # final position after portable is read data_in.read_int() # field count field_count = data_in.read_int() offset = data_in.position() for i in xrange(0, field_count): pos = data_in.read_int(offset + i * bits.INT_SIZE_IN_BYTES) data_in.set_position(pos) _len = data_in.read_short() field_name = bytearray(_len) data_in.read_into(field_name) field_type = data_in.read_byte() field_factory_id = 0 field_class_id = 0 if field_type == FieldType.PORTABLE: # is null if data_in.read_boolean(): register = False field_factory_id = data_in.read_int() field_class_id = data_in.read_int() # TODO: what there's a null inner Portable field if register: field_version = data_in.read_int() self.read_class_definition(data_in, field_factory_id, field_class_id, field_version) elif field_type == FieldType.PORTABLE_ARRAY: k = data_in.read_int() field_factory_id = data_in.read_int() field_class_id = data_in.read_int() # TODO: what there's a null inner Portable field if k > 0: p = data_in.read_int() data_in.set_position(p) field_version = data_in.read_int() self.read_class_definition(data_in, field_factory_id, field_class_id, field_version) else: register = False builder.add_field_def(FieldDefinition(i, field_name.decode('ascii'), field_type, field_factory_id, field_class_id)) class_def = builder.build() if register: class_def = self.register_class_definition(class_def) return class_def
def test_classes_with_same_class_id_in_different_factories(self): config = _Config() config.portable_factories = {1: {1: MyPortable1}, 2: {1: MyPortable2}} class_def1 = ClassDefinitionBuilder(1, 1).add_string_field("str_field").build() class_def2 = ClassDefinitionBuilder(2, 1).add_int_field("int_field").build() config.class_definitions = [class_def1, class_def2] ss = SerializationServiceV1(config) portable1 = MyPortable1("test") data1 = ss.to_data(portable1) self.assertEqual(portable1, ss.to_object(data1)) portable2 = MyPortable2(1) data2 = ss.to_data(portable2) self.assertEqual(portable2, ss.to_object(data2))
def _create_serialization_service(is_big_endian, int_type): config = _Config() config.custom_serializers = { CustomStreamSerializable: CustomStreamSerializer, CustomByteArraySerializable: CustomByteArraySerializer } config.is_big_endian = is_big_endian cdb = ClassDefinitionBuilder(PORTABLE_FACTORY_ID, INNER_PORTABLE_CLASS_ID) cdb.add_int_field("i") cdb.add_float_field("f") cd = cdb.build() config.class_definitions = [cd] config.portable_factories = { PORTABLE_FACTORY_ID: { PORTABLE_CLASS_ID: APortable, INNER_PORTABLE_CLASS_ID: AnInnerPortable } } config.data_serializable_factories = { IDENTIFIED_DATA_SERIALIZABLE_FACTORY_ID: { DATA_SERIALIZABLE_CLASS_ID: AnIdentifiedDataSerializable } } config.default_int_type = int_type return SerializationServiceV1(config)
def test_nested_null_portable_serialization(self): config = _Config() config.portable_factories = {1: {1: Parent, 2: Child}} child_class_def = ClassDefinitionBuilder( FACTORY_ID, 2).add_string_field("name").build() parent_class_def = (ClassDefinitionBuilder( FACTORY_ID, 1).add_portable_field("child", child_class_def).build()) config.class_definitions = [child_class_def, parent_class_def] ss = SerializationServiceV1(config) p = Parent(None) data = ss.to_data(p) self.assertEqual(p, ss.to_object(data))
def write_portable(self, field_name, portable): if portable is None: raise HazelcastSerializationError( "Cannot write None portable without explicitly registering class definition!" ) version = util.get_portable_version(portable, self.portable_context.portable_version) factory_id = portable.get_factory_id() class_id = portable.get_class_id() nested_builder = ClassDefinitionBuilder(factory_id, class_id, version) nested_class_def = self._create_nested_class_def(portable, nested_builder) self._builder.add_portable_field(field_name, nested_class_def)
def write_portable_array(self, field_name, values): if values is None or len(values) == 0: raise HazelcastSerializationError( "Cannot write None portable without explicitly registering class definition!" ) portable = values[0] _class_id = portable.get_class_id() for i in range(1, len(values)): if values[i].get_class_id() != _class_id: raise ValueError("Detected different class-ids in portable array!") version = util.get_portable_version(portable, self.portable_context.portable_version) nested_builder = ClassDefinitionBuilder( portable.get_factory_id(), portable.get_class_id(), version ) nested_class_def = self._create_nested_class_def(portable, nested_builder) self._builder.add_portable_array_field(field_name, nested_class_def)
class ClassDefinitionWriter(PortableWriter): def __init__(self, portable_context, factory_id=None, class_id=None, version=None, class_def_builder=None): self.portable_context = portable_context if class_def_builder is None: self._builder = ClassDefinitionBuilder(factory_id, class_id, version) else: self._builder = class_def_builder def write_byte(self, field_name, value): self._builder.add_byte_field(field_name) def write_boolean(self, field_name, value): self._builder.add_boolean_field(field_name) def write_char(self, field_name, value): self._builder.add_char_field(field_name) def write_short(self, field_name, value): self._builder.add_short_field(field_name) def write_int(self, field_name, value): self._builder.add_int_field(field_name) def write_long(self, field_name, value): self._builder.add_long_field(field_name) def write_float(self, field_name, value): self._builder.add_float_field(field_name) def write_double(self, field_name, value): self._builder.add_double_field(field_name) def write_utf(self, field_name, value): self._builder.add_utf_field(field_name) def write_byte_array(self, field_name, values): self._builder.add_byte_array_field(field_name) def write_boolean_array(self, field_name, values): self._builder.add_boolean_array_field(field_name) def write_char_array(self, field_name, values): self._builder.add_char_array_field(field_name) def write_short_array(self, field_name, values): self._builder.add_short_array_field(field_name) def write_int_array(self, field_name, values): self._builder.add_int_array_field(field_name) def write_long_array(self, field_name, values): self._builder.add_long_array_field(field_name) def write_float_array(self, field_name, values): self._builder.add_float_array_field(field_name) def write_double_array(self, field_name, values): self._builder.add_double_array_field(field_name) def write_utf_array(self, field_name, values): self._builder.add_utf_array_field(field_name) def write_portable(self, field_name, portable): if portable is None: raise HazelcastSerializationError( "Cannot write None portable without explicitly registering class definition!" ) version = util.get_portable_version( portable, self.portable_context.portable_version) factory_id = portable.get_factory_id() class_id = portable.get_class_id() nested_builder = ClassDefinitionBuilder(factory_id, class_id, version) nested_class_def = self._create_nested_class_def( portable, nested_builder) self._builder.add_portable_field(field_name, nested_class_def) def write_portable_array(self, field_name, values): if values is None or len(values) == 0: raise HazelcastSerializationError( "Cannot write None portable without explicitly registering class definition!" ) portable = values[0] _class_id = portable.get_class_id() for i in xrange(1, len(values)): if values[i].get_class_id() != _class_id: raise ValueError( "Detected different class-ids in portable array!") version = util.get_portable_version( portable, self.portable_context.portable_version) nested_builder = ClassDefinitionBuilder(portable.get_factory_id(), portable.get_class_id(), version) nested_class_def = self._create_nested_class_def( portable, nested_builder) self._builder.add_portable_array_field(field_name, nested_class_def) def write_null_portable(self, field_name, factory_id, class_id): nested_class_def = self.portable_context.lookup_class_definition( factory_id, class_id, self.portable_context.portable_version) if nested_class_def is None: raise HazelcastSerializationError( "Cannot write None portable without explicitly registering class definition!" ) self._builder.add_portable_field(field_name, nested_class_def) def get_raw_data_output(self): return EmptyObjectDataOutput() def _create_nested_class_def(self, portable, nested_builder): _writer = ClassDefinitionWriter(self.portable_context, class_def_builder=nested_builder) portable.write_portable(_writer) return self.portable_context.register_class_definition( nested_builder.build()) def register_and_get(self): cd = self._builder.build() return self.portable_context.register_class_definition(cd)
def test_portable_class_def(self): builder_inner = ClassDefinitionBuilder(FACTORY_ID, InnerPortable.CLASS_ID) builder_inner.add_utf_field("param_str") builder_inner.add_int_field("param_int") class_def_inner = builder_inner.build() builder = ClassDefinitionBuilder(FACTORY_ID, SerializationV1Portable.CLASS_ID) builder.add_byte_field("1") builder.add_boolean_field("2") builder.add_char_field("3") builder.add_short_field("4") builder.add_int_field("5") builder.add_long_field("6") builder.add_float_field("7") builder.add_double_field("8") builder.add_utf_field("9") builder.add_byte_array_field("a1") builder.add_boolean_array_field("a2") builder.add_char_array_field("a3") builder.add_short_array_field("a4") builder.add_int_array_field("a5") builder.add_long_array_field("a6") builder.add_float_array_field("a7") builder.add_double_array_field("a8") builder.add_utf_array_field("a9") builder.add_portable_field("p", class_def_inner) builder.add_portable_array_field("ap", class_def_inner) class_def = builder.build() config = hazelcast.ClientConfig() config.serialization_config.portable_factories[ FACTORY_ID] = the_factory config.serialization_config.class_definitions.add(class_def) config.serialization_config.class_definitions.add(class_def_inner) service = SerializationServiceV1(config.serialization_config) service2 = SerializationServiceV1(config.serialization_config) obj = SerializationV1Portable() data = service.to_data(obj) obj2 = service2.to_object(data) self.assertTrue(obj == obj2)
def __init__(self, portable_context, factory_id, class_id, version, class_def_builder=None): self.portable_context = portable_context if class_def_builder is None: self._builder = ClassDefinitionBuilder(factory_id, class_id, version) else: self._builder = class_def_builder
class ClassDefinitionWriter(PortableWriter): def __init__(self, portable_context, factory_id, class_id, version, class_def_builder=None): self.portable_context = portable_context if class_def_builder is None: self._builder = ClassDefinitionBuilder(factory_id, class_id, version) else: self._builder = class_def_builder def write_utf_array(self, field_name, values): self._builder.add_utf_array_field(field_name) def write_utf(self, field_name, value): self._builder.add_utf_array_field(field_name) def write_short_array(self, field_name, values): self._builder.add_utf_field(field_name) def write_short(self, field_name, value): self._builder.add_short_field(field_name) def write_portable_array(self, field_name, values): if values is None or len(values) == 0: raise HazelcastSerializationError("Cannot write None portable without explicitly registering class definition!") portable = values[0] _class_id = portable.get_class_id() for i in xrange(1, len(values)): if values[i].get_class_id() != _class_id: raise ValueError("Detected different class-ids in portable array!") version = util.get_portable_version(portable, self.portable_context.get_version()) nested_builder = ClassDefinitionBuilder(portable.get_factory_id(), portable.get_class_id(), version) nested_class_def = self._create_nested_class_def(portable, nested_builder) self._builder.add_portable_array_field(field_name, nested_class_def) def write_portable(self, field_name, portable): if portable is None: raise HazelcastSerializationError("Cannot write None portable without explicitly registering class definition!") version = util.get_portable_version(portable, self.portable_context.get_version()) nested_builder = ClassDefinitionBuilder(portable.get_factory_id(), portable.get_class_id(), version) nested_class_def = self._create_nested_class_def(portable, nested_builder) self._builder.add_portable_field(field_name, nested_class_def) def write_null_portable(self, field_name, factory_id, class_id): nested_class_def = self.portable_context.lookup_class_definition(factory_id,class_id, self.portable_context.get_version()) if nested_class_def is None: raise HazelcastSerializationError("Cannot write None portable without explicitly registering class definition!") self._builder.add_portable_field(field_name, nested_class_def) def write_long_array(self, field_name, values): self._builder.add_long_array_field(field_name) def write_long(self, field_name, value): self._builder.add_long_field(field_name) def write_int_array(self, field_name, values): self._builder.add_int_array_field(field_name) def write_int(self, field_name, value): self._builder.add_int_field(field_name) def write_float_array(self, field_name, values): self._builder.add_float_array_field(field_name) def write_float(self, field_name, value): self._builder.add_float_field(field_name) def write_double_array(self, field_name, values): self._builder.add_double_array_field(field_name) def write_double(self, field_name, value): self._builder.add_double_field(field_name) def write_char_array(self, field_name, values): self._builder.add_char_array_field(field_name) def write_char(self, field_name, value): self._builder.add_char_field(field_name) def write_byte_array(self, field_name, values): self._builder.add_byte_array_field(field_name) def write_byte(self, field_name, value): self._builder.add_byte_field(field_name) def write_boolean_array(self, field_name, values): self._builder.add_boolean_array_field(field_name) def write_boolean(self, field_name, value): self._builder.add_boolean_field(field_name) def get_raw_data_output(self): return EmptyObjectDataOutput() def _create_nested_class_def(self, portable, nested_builder): _writer = ClassDefinitionWriter(self.portable_context, nested_builder) portable.write_portable(_writer) return self.portable_context.register_class_definition(nested_builder.build())
def test_portable_class_def(self): builder_inner = ClassDefinitionBuilder(FACTORY_ID, InnerPortable.CLASS_ID) builder_inner.add_utf_field("param_str") builder_inner.add_int_field("param_int") class_def_inner = builder_inner.build() builder = ClassDefinitionBuilder(FACTORY_ID, SerializationV1Portable.CLASS_ID) builder.add_byte_field("1") builder.add_boolean_field("2") builder.add_char_field("3") builder.add_short_field("4") builder.add_int_field("5") builder.add_long_field("6") builder.add_float_field("7") builder.add_double_field("8") builder.add_utf_field("9") builder.add_byte_array_field("a1") builder.add_boolean_array_field("a2") builder.add_char_array_field("a3") builder.add_short_array_field("a4") builder.add_int_array_field("a5") builder.add_long_array_field("a6") builder.add_float_array_field("a7") builder.add_double_array_field("a8") builder.add_utf_array_field("a9") builder.add_portable_field("p", class_def_inner) builder.add_portable_array_field("ap", class_def_inner) class_def = builder.build() config = hazelcast.ClientConfig() config.serialization_config.portable_factories[FACTORY_ID] = the_factory config.serialization_config.class_definitions.add(class_def) config.serialization_config.class_definitions.add(class_def_inner) service = SerializationServiceV1(config.serialization_config) service2 = SerializationServiceV1(config.serialization_config) obj = SerializationV1Portable() data = service.to_data(obj) obj2 = service2.to_object(data) self.assertTrue(obj == obj2)
def test_class_definition_with_duplicate_field_names_with_different_types(self): with self.assertRaises(HazelcastSerializationError): ClassDefinitionBuilder(1, 1).add_string_field("name").add_int_field("name")