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