def _check(self, field_name):
if field_name in self._field_names:
raise HazelcastSerializationError(
"Field with the name %s already exists" % field_name)
self._field_names.add(field_name)
if self._done:
raise HazelcastSerializationError(
"ClassDefinition is already built for %s" % self.class_id)
def create_new_portable_instance(self, factory_id, class_id):
try:
portable_factory = self._portable_factories[factory_id]
except KeyError:
raise HazelcastSerializationError("Could not find portable_factory for factory-id: {}".format(factory_id))
portable = portable_factory[class_id]
if portable is None:
raise HazelcastSerializationError("Could not create Portable for class-id: {}".format(class_id))
return portable()
def _check_portable_attributes(field_def, portable):
if field_def.factory_id != portable.get_factory_id():
raise HazelcastSerializationError(
"Wrong Portable type! Generic portable types are not supported! "
"Expected factory-id: %s, Actual factory-id: %s" %
(field_def.factory_id, portable.get_factory_id()))
if field_def.class_id != portable.get_class_id():
raise HazelcastSerializationError(
"Wrong Portable type! Generic portable types are not supported! "
"Expected class-id: %s, Actual class-id: %s" %
(field_def.class_id, portable.get_class_id()))
def _read_position(self, field_name, field_type):
if self._raw:
raise HazelcastSerializationError(
"Cannot read Portable fields after get_raw_data_input() is called!"
)
fd = self._class_def.get_field(field_name)
if fd is None:
return self._read_nested_position(field_name, field_type)
if fd.field_type != field_type:
raise HazelcastSerializationError("Not a '%s' field: %s" % (field_type, field_name))
return self._read_position_by_field_def(fd)
def handle_exception(e, traceback):
if isinstance(e, MemoryError):
re_raise(MemoryError("OUT OF MEMORY"), traceback)
elif isinstance(e, HazelcastSerializationError):
re_raise(e, traceback)
else:
re_raise(HazelcastSerializationError(e.args[0]), traceback)
def to_object(self, data):
"""
Deserialize input data
:param data: serialized input Data object
:return: Deserialized object
"""
if not isinstance(data, Data):
return data
if is_null_data(data):
return None
inp = self._create_data_input(data)
try:
type_id = data.get_type()
serializer = self._registry.serializer_by_type_id(type_id)
if serializer is None:
if self._active:
raise HazelcastSerializationError(
"Missing Serializer for type-id:{}".format(type_id))
else:
raise HazelcastInstanceNotActiveError()
return serializer.read(inp)
except:
handle_exception(sys.exc_info()[1], sys.exc_info()[2])
finally:
pass
def read_portable_array(self, field_name):
current_pos = self._in.position()
try:
fd = self._class_def.get_field(field_name)
if fd is None:
raise self._create_unknown_field_exception(field_name)
if fd.field_type != FieldType.PORTABLE_ARRAY:
raise HazelcastSerializationError(
"Not a portable array field: %s" % field_name)
pos = self._read_position_by_field_def(fd)
self._in.set_position(pos)
length = self._in.read_int()
factory_id = self._in.read_int()
class_id = self._in.read_int()
if length == bits.NULL_ARRAY_LENGTH:
return None
_check_factory_and_class(fd, factory_id, class_id)
portables = [None] * length
if length > 0:
offset = self._in.position()
for i in range(0, length):
start = self._in.read_int(offset +
i * bits.INT_SIZE_IN_BYTES)
self._in.set_position(start)
portables[i] = self._portable_serializer.read_internal(
self._in, factory_id, class_id)
return portables
finally:
self._in.set_position(current_pos)
def _read_nested_position(self, field_name, field_type):
field_names = field_name.split(".")
if len(field_names) > 1:
fd = None
_reader = self
for i in range(0, len(field_names)):
fd = _reader._class_def.get_field(field_names[i])
if fd is None:
break
if i == len(field_names) - 1:
break
pos = _reader._read_position_by_field_def(fd)
self._in.set_position(pos)
is_none = self._in.read_boolean()
if is_none:
raise ValueError("Parent field is null: %s" %
field_names[i])
_reader = self._portable_serializer.create_default_reader(
self._in)
if fd is None:
raise self._create_unknown_field_exception(field_name)
if fd.field_type != field_type:
raise HazelcastSerializationError("Not a '%s' field: %s" %
(field_type, field_name))
return _reader._read_position_by_field_def(fd)
raise self._create_unknown_field_exception(field_name)
def read_portable(self, field_name):
cur_pos = self._in.position()
try:
fd = self._class_def.get_field(field_name)
if fd is None:
raise self._create_unknown_field_exception(field_name)
if fd.field_type != FieldType.PORTABLE:
raise HazelcastSerializationError("Not a Portable field: %s" %
field_name)
pos = self._read_position_by_field_def(fd)
self._in.set_position(pos)
is_none = self._in.read_boolean()
factory_id = self._in.read_int()
class_id = self._in.read_int()
_check_factory_and_class(fd, factory_id, class_id)
if is_none:
return None
return self._portable_serializer.read_internal(
self._in, factory_id, class_id)
finally:
self._in.set_position(cur_pos)
def _set_position(self, field_name, field_type):
if self._raw:
raise HazelcastSerializationError(
"Cannot write Portable fields after get_raw_data_output() is called!"
)
fd = self._class_def.get_field(field_name)
if fd is None:
raise HazelcastSerializationError(
"Invalid field name:'%s' for ClassDefinition(id:%s , version:%s )"
% (field_name, self._class_def.class_id, self._class_def.version)
)
if field_name not in self._writen_fields:
self._write_field_def(fd.index, field_name, field_type)
self._writen_fields.add(field_name)
else:
raise HazelcastSerializationError("Field '%s' has already been written!" % field_name)
return fd
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 register_fetched_schema(self, schema_id: int,
schema: typing.Optional[Schema]) -> None:
if not schema:
raise HazelcastSerializationError(
f"The schema with the id {schema_id} can not be found in the cluster."
)
self._compact_serializer.register_schema_to_id(schema)
def handle_exception(e, traceback):
if isinstance(e, MemoryError):
# TODO
six.print_("OUT OF MEMORY")
six.reraise(MemoryError, e, traceback)
elif isinstance(e, HazelcastSerializationError):
six.reraise(HazelcastSerializationError, e, traceback)
else:
six.reraise(HazelcastSerializationError,
HazelcastSerializationError(e.args[0]), traceback)
def write_object(self, out, obj):
if isinstance(obj, Data):
raise HazelcastSerializationError(
"Cannot write a Data instance! Use write_data(out, data) instead."
)
try:
serializer = self._registry.serializer_for(obj)
out.write_int(serializer.get_type_id())
serializer.write(out, obj)
except:
handle_exception(sys.exc_info()[1], sys.exc_info()[2])
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 read(self, inp):
is_identified = inp.read_boolean()
if not is_identified:
raise HazelcastSerializationError(
"Native clients only support IdentifiedDataSerializable!")
factory_id = inp.read_int()
class_id = inp.read_int()
factory = self._factories.get(factory_id, None)
if factory is None:
raise HazelcastSerializationError(
"No DataSerializerFactory registered for namespace: %s" %
factory_id)
identified = factory.get(class_id, None)
if identified is None:
raise HazelcastSerializationError(
"%s is not be able to create an instance for id: %s on factoryId: %s"
% (factory, class_id, factory_id))
instance = identified()
instance.read_data(inp)
return instance
def read_object(self, inp):
try:
type_id = inp.read_int()
serializer = self._registry.serializer_by_type_id(type_id)
if serializer is None:
if self._active:
raise HazelcastSerializationError(
"Missing Serializer for type-id:{}".format(type_id))
else:
raise HazelcastInstanceNotActiveError()
return serializer.read(inp)
except:
handle_exception(sys.exc_info()[1], sys.exc_info()[2])
def register(self, class_def):
with self._lock:
if class_def is None:
return None
if class_def.factory_id != self._factory_id:
raise HazelcastSerializationError(
"Invalid factory-id! %s -> %s" %
(self._factory_id, class_def))
if isinstance(class_def, ClassDefinition):
class_def.set_version_if_not_set(self._portable_version)
combined_key = (class_def.class_id, class_def.version)
if combined_key not in self._versioned_definitions:
self._versioned_definitions[combined_key] = class_def
return class_def
current_class_def = self._versioned_definitions[combined_key]
if isinstance(current_class_def, ClassDefinition):
if current_class_def != class_def:
raise HazelcastSerializationError(
"Incompatible class-definitions with same class-id: %s vs %s"
% (class_def, current_class_def))
return current_class_def
self._versioned_definitions[combined_key] = class_def
return class_def
def __init__(self, portable_serializer, data_input, class_def):
self._portable_serializer = portable_serializer
self._in = data_input
self._class_def = class_def
try:
# final position after portable is read
self._final_pos = data_input.read_int()
# field count
field_count = data_input.read_int()
except Exception:
raise HazelcastSerializationError()
if field_count != class_def.get_field_count():
raise ValueError("Field count(%s) in stream does not match! %s" %
(field_count, class_def))
self._offset = data_input.position()
self._raw = False
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)
def serializer_for(self, obj):
"""Searches for a serializer for the provided object
Serializers will be searched in this order;
- NULL serializer
- Default serializers, like primitives, arrays, string and some default types
- Custom registered types by user
- Global serializer if registered by user
- pickle serialization as a fallback
Args:
obj: Input object
Returns:
The serializer
"""
# 1-NULL serializer
if obj is None:
return self._null_serializer
obj_type = type(obj)
# 2-Default serializers, DataSerializable, Portable, primitives, arrays, String, UUID
# and some helper types(BigInteger etc)
serializer = self.lookup_default_serializer(obj_type, obj)
# 3-Custom registered types by user
if serializer is None:
serializer = self.lookup_custom_serializer(obj_type)
# 5-Global serializer if registered by user
if serializer is None:
serializer = self.lookup_global_serializer(obj_type)
# 4 Internal serializer
if serializer is None:
serializer = self.lookup_python_serializer(obj_type)
if serializer is None:
raise HazelcastSerializationError(
"There is no suitable serializer for:" + str(obj_type))
return serializer
def _check(self):
if self._done:
raise HazelcastSerializationError(
"ClassDefinition is already built for %s" % self.class_id)
def _create_unknown_field_exception(self, field_name):
return HazelcastSerializationError(
"Unknown field name: '%s' for ClassDefinition(id=%s, version=%s)" %
(field_name, self._class_def.class_id, self._class_def.version))
def _create_unknown_field_exception(self, field_name):
return HazelcastSerializationError(
"Unknown field name: '{}' for ClassDefinition[ id: {}, version: {} ]"
.format(field_name, self._class_def.class_id,
self._class_def.version))