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