def test_portable_read_without_factory(self): config = hazelcast.ClientConfig() config.serialization.portable_factories[FACTORY_ID] = the_factory service = SerializationServiceV1(config.serialization) service2 = SerializationServiceV1(hazelcast.SerializationConfig()) obj = create_portable() self.assertTrue(obj.inner_portable) data = service.to_data(obj) with self.assertRaises(HazelcastSerializationError): service2.to_object(data)
def test_encode_decode_2(self): config = hazelcast.ClientConfig() config.serialization.portable_factories[FACTORY_ID] = the_factory service = SerializationServiceV1(config.serialization) service2 = SerializationServiceV1(config.serialization) obj = create_portable() self.assertTrue(obj.inner_portable) data = service.to_data(obj) obj2 = service2.to_object(data) self.assertTrue(obj == obj2)
def test_portable_read_without_factory(self): config = _Config() config.portable_factories = {FACTORY_ID: the_factory} service = SerializationServiceV1(config) service2 = SerializationServiceV1(_Config()) obj = create_portable() self.assertTrue(obj.inner_portable) data = service.to_data(obj) with self.assertRaises(HazelcastSerializationError): service2.to_object(data)
def test_encode_decode_2(self): config = _Config() config.portable_factories = {FACTORY_ID: the_factory} service = SerializationServiceV1(config) service2 = SerializationServiceV1(config) obj = create_portable() self.assertTrue(obj.inner_portable) data = service.to_data(obj) obj2 = service2.to_object(data) self.assertTrue(obj == obj2)
def test_portable_null_fields(self): config = _Config() config.portable_factories = {FACTORY_ID: the_factory} service = SerializationServiceV1(config) service.to_data(create_portable()) service2 = SerializationServiceV1(config) obj = SerializationV1Portable() data = service.to_data(obj) obj2 = service2.to_object(data) self.assertTrue(obj == obj2)
def test_portable_null_fields(self): config = hazelcast.ClientConfig() config.serialization.portable_factories[FACTORY_ID] = the_factory service = SerializationServiceV1(config.serialization) service.to_data(create_portable()) service2 = SerializationServiceV1(config.serialization) obj = SerializationV1Portable() data = service.to_data(obj) obj2 = service2.to_object(data) self.assertTrue(obj == obj2)
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_portable_serialization(self): serialization_config = hazelcast.SerializationConfig() serialization_config.portable_version = 6 serialization_config.portable_factories[1] = {1: Parent, 2: Child} ss1 = SerializationServiceV1(serialization_config) ss2 = SerializationServiceV1(serialization_config) ss2.to_data(Child("Joe")) p = Parent(Child("Joe")) data = ss1.to_data(p) self.assertEqual(p, ss2.to_object(data))
def setUp(self): config1 = SerializationConfig() config1.add_portable_factory(FACTORY_ID, the_factory_1) config2 = SerializationConfig() config2.add_portable_factory(FACTORY_ID, the_factory_2) self.service1 = SerializationServiceV1(serialization_config=config1) self.service2 = SerializationServiceV1(serialization_config=config2) base_portable = create_portable() data = self.service1.to_data(base_portable) inp = self.service2._create_data_input(data) portable_serializer = self.service2._registry._portable_serializer self.reader = portable_serializer.create_morphing_reader(inp)
def __init__(self, config=None): self.config = config or ClientConfig() self.properties = ClientProperties(self.config.get_properties()) self.id = HazelcastClient.CLIENT_ID.get_and_increment() self.name = self._create_client_name() self._init_logger() self._logger_extras = {"client_name": self.name, "group_name": self.config.group_config.name} self._log_group_password_info() self.lifecycle = LifecycleService(self.config, self._logger_extras) self.reactor = AsyncoreReactor(self._logger_extras) self._address_providers = self._create_address_providers() self._address_translator = self._create_address_translator() self.connection_manager = ConnectionManager(self, self.reactor.new_connection, self._address_translator) self.heartbeat = Heartbeat(self) self.invoker = InvocationService(self) self.listener = ListenerService(self) self.cluster = ClusterService(self.config, self, self._address_providers) self.partition_service = PartitionService(self) self.proxy = ProxyManager(self) self.load_balancer = RandomLoadBalancer(self.cluster) self.serialization_service = SerializationServiceV1(serialization_config=self.config.serialization_config) self.transaction_manager = TransactionManager(self) self.lock_reference_id_generator = AtomicInteger(1) self.near_cache_manager = NearCacheManager(self) self.statistics = Statistics(self) self._start()
def setUp(self): config1 = _Config() config1.portable_factories = {FACTORY_ID: the_factory_1} config2 = _Config() config2.portable_factories = {FACTORY_ID: the_factory_2} self.service1 = SerializationServiceV1(config1) self.service2 = SerializationServiceV1(config2) base_portable = create_portable() data = self.service1.to_data(base_portable) inp = self.service2._create_data_input(data) portable_serializer = self.service2._registry._portable_serializer self.reader = portable_serializer.create_morphing_reader(inp)
def __init__(self, **kwargs): config = _Config.from_dict(kwargs) self._config = config self._context = _ClientContext() client_id = HazelcastClient._CLIENT_ID.get_and_increment() self.name = self._create_client_name(client_id) self._reactor = AsyncoreReactor() self._serialization_service = SerializationServiceV1(config) self._near_cache_manager = NearCacheManager( config, self._serialization_service) self._internal_lifecycle_service = _InternalLifecycleService(config) self.lifecycle_service = LifecycleService( self._internal_lifecycle_service) self._invocation_service = InvocationService(self, config, self._reactor) self._address_provider = self._create_address_provider() self._internal_partition_service = _InternalPartitionService(self) self.partition_service = PartitionService( self._internal_partition_service, self._serialization_service) self._internal_cluster_service = _InternalClusterService(self, config) self.cluster_service = ClusterService(self._internal_cluster_service) self._connection_manager = ConnectionManager( self, config, self._reactor, self._address_provider, self._internal_lifecycle_service, self._internal_partition_service, self._internal_cluster_service, self._invocation_service, self._near_cache_manager, ) self._load_balancer = self._init_load_balancer(config) self._listener_service = ListenerService(self, config, self._connection_manager, self._invocation_service) self._proxy_manager = ProxyManager(self._context) self.cp_subsystem = CPSubsystem(self._context) self._proxy_session_manager = ProxySessionManager(self._context) self._transaction_manager = TransactionManager(self._context) self._lock_reference_id_generator = AtomicInteger(1) self._statistics = Statistics( self, config, self._reactor, self._connection_manager, self._invocation_service, self._near_cache_manager, ) self._cluster_view_listener = ClusterViewListenerService( self, self._connection_manager, self._internal_partition_service, self._internal_cluster_service, self._invocation_service, ) self._shutdown_lock = threading.RLock() self._init_context() self._start()
def __init__(self, name): threading.Thread.__init__(self, name=name) self.gets = 0 self.puts = 0 self.removes = 0 self.setDaemon(True) self.my_map = dict() self.ss = SerializationServiceV1(serialization_config=SerializationConfig())
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 setUp(self): config1 = _Config() config1.portable_factories = {FACTORY_ID: the_factory_1} config2 = _Config() config2.portable_factories = {FACTORY_ID: the_factory_2} self.service1 = SerializationServiceV1(config1) self.service2 = SerializationServiceV1(config2) base_portable = create_portable() data = self.service1.to_data(base_portable) inp = _ObjectDataInput(data.buffer, DATA_OFFSET, self.service2, self.service2._is_big_endian) portable_serializer = self.service2._registry._portable_serializer self.reader = portable_serializer.create_morphing_reader(inp)
def setUp(self): logging.basicConfig( format= '%(asctime)s%(msecs)03d [%(name)s] %(levelname)s: %(message)s', datefmt="%H:%M%:%S,") logging.getLogger().setLevel(logging.DEBUG) self.service = SerializationServiceV1( serialization_config=SerializationConfig())
def test_factory(self): config = hazelcast.ClientConfig() config.serialization_config.data_serializable_factories[FACTORY_ID] = the_factory service = SerializationServiceV1(config.serialization_config) obj = SampleIdentified(1, True, "a", 0x1234, 0x12345678, 0x1234567890123456, 1.0, 2.2, "TEST") data = service.to_data(obj) obj2 = service.to_object(data) self.assertTrue(obj == obj2)
def test_encode_decode(self): config = _Config() config.data_serializable_factories = {FACTORY_ID: the_factory} service = SerializationServiceV1(config) obj = create_identified() data = service.to_data(obj) obj2 = service.to_object(data) self.assertTrue(obj == obj2)
def test_encode_decode(self): config = hazelcast.ClientConfig() config.serialization.data_serializable_factories[ FACTORY_ID] = the_factory service = SerializationServiceV1(config.serialization) obj = create_identified() data = service.to_data(obj) obj2 = service.to_object(data) self.assertTrue(obj == obj2)
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 test_encode_decode_respect_bytearray_fields(self): config = hazelcast.ClientConfig() config.set_property("hazelcast.serialization.input.returns.bytearray", True) config.serialization_config.data_serializable_factories[ FACTORY_ID] = the_factory service = SerializationServiceV1(config.serialization_config, properties=ClientProperties( config.get_properties())) obj = create_identified_with_bytearray() data = service.to_data(obj) obj2 = service.to_object(data) self.assertTrue(obj == obj2) service = SerializationServiceV1(config.serialization_config) obj2 = service.to_object(data) self.assertFalse(obj == obj2)
def __init__(self, config=None): self._context = _ClientContext() self.config = config or ClientConfig() self.properties = ClientProperties(self.config.get_properties()) self._id = HazelcastClient._CLIENT_ID.get_and_increment() self.name = self._create_client_name() self._init_logger() self._logger_extras = { "client_name": self.name, "cluster_name": self.config.cluster_name } self._reactor = AsyncoreReactor(self._logger_extras) self._serialization_service = SerializationServiceV1( serialization_config=self.config.serialization) self._near_cache_manager = NearCacheManager( self, self._serialization_service) self._internal_lifecycle_service = _InternalLifecycleService( self, self._logger_extras) self.lifecycle_service = LifecycleService( self._internal_lifecycle_service) self._invocation_service = InvocationService(self, self._reactor, self._logger_extras) self._address_provider = self._create_address_provider() self._internal_partition_service = _InternalPartitionService( self, self._logger_extras) self.partition_service = PartitionService( self._internal_partition_service) self._internal_cluster_service = _InternalClusterService( self, self._logger_extras) self.cluster_service = ClusterService(self._internal_cluster_service) self._connection_manager = ConnectionManager( self, self._reactor, self._address_provider, self._internal_lifecycle_service, self._internal_partition_service, self._internal_cluster_service, self._invocation_service, self._near_cache_manager, self._logger_extras) self._load_balancer = self._init_load_balancer(self.config) self._listener_service = ListenerService(self, self._connection_manager, self._invocation_service, self._logger_extras) self._proxy_manager = ProxyManager(self._context) self._transaction_manager = TransactionManager(self._context, self._logger_extras) self._lock_reference_id_generator = AtomicInteger(1) self._statistics = Statistics(self, self._reactor, self._connection_manager, self._invocation_service, self._near_cache_manager, self._logger_extras) self._cluster_view_listener = ClusterViewListenerService( self, self._connection_manager, self._internal_partition_service, self._internal_cluster_service, self._invocation_service) self._shutdown_lock = threading.RLock() self._init_context() self._start()
def test_nested_portable_serialization(self): config = _Config() config.portable_version = 6 config.portable_factories = { 1: { 1: Parent, 2: Child, } } ss1 = SerializationServiceV1(config) ss2 = SerializationServiceV1(config) ss2.to_data(Child("Joe")) p = Parent(Child("Joe")) data = ss1.to_data(p) self.assertEqual(p, ss2.to_object(data))
def test_encode_decode(self): config = _Config() config.portable_factories = {FACTORY_ID: the_factory} service = SerializationServiceV1(config) obj = create_portable() self.assertTrue(obj.inner_portable) data = service.to_data(obj) obj2 = service.to_object(data) self.assertTrue(obj == obj2) self.assertEqual(obj.inner_portable.param_int, obj2.nested_field)
def test_portable_context(self): config = _Config() config.portable_factories = {FACTORY_ID: the_factory} service = SerializationServiceV1(config) obj = create_portable() self.assertTrue(obj.inner_portable) service.to_data(obj) class_definition = service._portable_context.lookup_class_definition( FACTORY_ID, InnerPortable.CLASS_ID, 0) self.assertTrue(class_definition is not None)
def __init__(self): service = SerializationServiceV1(None) key = "Test" * 1000 self.name = "name" * 10 self.key = service.to_data(key) self.thread_id = 1l msg = ClientMessage(payload_size=calculate_size_data( self.key)).append_bool(False).append_data( self.key).update_frame_length() self.response_message = ClientMessage(msg.buffer) self.request = None self.response = None
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 __init__(self, config=None): self.config = config or ClientConfig() self.lifecycle = LifecycleService(self.config) self.reactor = AsyncoreReactor() self.connection_manager = ConnectionManager( self, self.reactor.new_connection) self.heartbeat = Heartbeat(self) self.invoker = InvocationService(self) self.listener = ListenerService(self) self.cluster = ClusterService(self.config, self) self.partition_service = PartitionService(self) self.proxy = ProxyManager(self) self.load_balancer = RandomLoadBalancer(self.cluster) self.serializer = SerializationServiceV1( serialization_config=self.config.serialization_config) self.transaction_manager = TransactionManager(self) self._start()
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 __init__(self, config=None): self.config = config or ClientConfig() self.properties = ClientProperties(self.config.get_properties()) self.lifecycle = LifecycleService(self.config) self.reactor = AsyncoreReactor() self._address_providers = self._create_address_providers() self._address_translator = self._create_address_translator() self.connection_manager = ConnectionManager( self, self.reactor.new_connection, self._address_translator) self.heartbeat = Heartbeat(self) self.invoker = InvocationService(self) self.listener = ListenerService(self) self.cluster = ClusterService(self.config, self, self._address_providers) self.partition_service = PartitionService(self) self.proxy = ProxyManager(self) self.load_balancer = RandomLoadBalancer(self.cluster) self.serialization_service = SerializationServiceV1( serialization_config=self.config.serialization_config) self.transaction_manager = TransactionManager(self) self.lock_reference_id_generator = LockReferenceIdGenerator() self._start()