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