diff --git a/hazelcast/client.py b/hazelcast/client.py index d47d92f8b1..c2e2e9d630 100644 --- a/hazelcast/client.py +++ b/hazelcast/client.py @@ -315,25 +315,26 @@ class SomeClassSerializer(StreamSerializer): def __init__(self, **kwargs): config = _Config.from_dict(kwargs) - self.config = config + 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(self, self._serialization_service) - self._internal_lifecycle_service = _InternalLifecycleService(self) + 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, self._reactor) + 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) + 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, @@ -344,7 +345,7 @@ def __init__(self, **kwargs): ) self._load_balancer = self._init_load_balancer(config) self._listener_service = ListenerService( - self, self._connection_manager, self._invocation_service + self, config, self._connection_manager, self._invocation_service ) self._proxy_manager = ProxyManager(self._context) self.cp_subsystem = CPSubsystem(self._context) @@ -353,6 +354,7 @@ def __init__(self, **kwargs): self._lock_reference_id_generator = AtomicInteger(1) self._statistics = Statistics( self, + config, self._reactor, self._connection_manager, self._invocation_service, @@ -371,7 +373,7 @@ def __init__(self, **kwargs): def _init_context(self): self._context.init_context( - self.config, + self._config, self._invocation_service, self._internal_partition_service, self._internal_cluster_service, @@ -393,11 +395,11 @@ def _start(self): self._internal_partition_service, self._connection_manager, self._listener_service ) self._internal_lifecycle_service.start() - membership_listeners = self.config.membership_listeners + membership_listeners = self._config.membership_listeners self._internal_cluster_service.start(self._connection_manager, membership_listeners) self._cluster_view_listener.start() self._connection_manager.start(self._load_balancer) - if not self.config.async_start: + if not self._config.async_start: self._internal_cluster_service.wait_initial_member_list_fetched() self._connection_manager.connect_to_all_cluster_members() @@ -569,7 +571,7 @@ def add_distributed_object_listener(self, listener_func): Returns: hazelcast.future.Future[str]: A registration id which is used as a key to remove the listener. """ - is_smart = self.config.smart_routing + is_smart = self._config.smart_routing codec = client_add_distributed_object_listener_codec request = codec.encode_request(is_smart) @@ -648,7 +650,7 @@ def shutdown(self): self._internal_lifecycle_service.fire_lifecycle_event(LifecycleState.SHUTDOWN) def _create_address_provider(self): - config = self.config + config = self._config cluster_members = config.cluster_members address_list_provided = len(cluster_members) > 0 cloud_discovery_token = config.cloud_discovery_token @@ -667,7 +669,7 @@ def _create_address_provider(self): return DefaultAddressProvider(cluster_members) def _create_client_name(self, client_id): - client_name = self.config.client_name + client_name = self._config.client_name if client_name: return client_name return "hz.client_%s" % client_id diff --git a/hazelcast/cluster.py b/hazelcast/cluster.py index bf933812d3..e94ac203d8 100644 --- a/hazelcast/cluster.py +++ b/hazelcast/cluster.py @@ -108,10 +108,9 @@ def get_members(self, member_selector=None): class _InternalClusterService(object): - def __init__(self, client): + def __init__(self, client, config): self._client = client self._connection_manager = None - config = client.config self._labels = frozenset(config.labels) self._listeners = {} self._member_list_snapshot = _EMPTY_SNAPSHOT diff --git a/hazelcast/connection.py b/hazelcast/connection.py index 6a2f043599..582d8993c2 100644 --- a/hazelcast/connection.py +++ b/hazelcast/connection.py @@ -95,6 +95,7 @@ class ConnectionManager(object): def __init__( self, client, + config, reactor, address_provider, lifecycle_service, @@ -108,6 +109,7 @@ def __init__( self.client_uuid = uuid.uuid4() self._client = client + self._config = config self._reactor = reactor self._address_provider = address_provider self._lifecycle_service = lifecycle_service @@ -115,11 +117,12 @@ def __init__( self._cluster_service = cluster_service self._invocation_service = invocation_service self._near_cache_manager = near_cache_manager - config = self._client.config self._smart_routing_enabled = config.smart_routing self._wait_strategy = self._init_wait_strategy(config) self._reconnect_mode = config.reconnect_mode - self._heartbeat_manager = _HeartbeatManager(self, self._client, reactor, invocation_service) + self._heartbeat_manager = _HeartbeatManager( + self, self._client, config, reactor, invocation_service + ) self._connection_listeners = [] self._connect_all_members_timer = None self._async_start = config.async_start @@ -368,10 +371,10 @@ def _sync_connect_to_cluster(self): if not self._wait_strategy.sleep(): break except (ClientNotAllowedInClusterError, InvalidConfigurationError): - cluster_name = self._client.config.cluster_name + cluster_name = self._config.cluster_name _logger.exception("Stopped trying on cluster %s", cluster_name) - cluster_name = self._client.config.cluster_name + cluster_name = self._config.cluster_name _logger.info( "Unable to connect to any address from the cluster with name: %s. " "The following addresses were tried: %s", @@ -422,7 +425,7 @@ def _get_or_connect(self, address): self, self._connection_id_generator.get_and_increment(), translated, - self._client.config, + self._config, self._invocation_service.handle_client_message, ) except IOError: @@ -437,7 +440,7 @@ def _get_or_connect(self, address): def _authenticate(self, connection): client = self._client - cluster_name = client.config.cluster_name + cluster_name = self._config.cluster_name client_name = client.name request = client_authentication_codec.encode_request( cluster_name, @@ -585,12 +588,11 @@ def _get_possible_addresses(self): class _HeartbeatManager(object): _heartbeat_timer = None - def __init__(self, connection_manager, client, reactor, invocation_service): + def __init__(self, connection_manager, client, config, reactor, invocation_service): self._connection_manager = connection_manager self._client = client self._reactor = reactor self._invocation_service = invocation_service - config = client.config self._heartbeat_timeout = config.heartbeat_timeout self._heartbeat_interval = config.heartbeat_interval diff --git a/hazelcast/invocation.py b/hazelcast/invocation.py index 25f2260094..ad7f8633e3 100644 --- a/hazelcast/invocation.py +++ b/hazelcast/invocation.py @@ -84,8 +84,7 @@ def set_exception(self, exception, traceback=None): class InvocationService(object): _CLEAN_RESOURCES_PERIOD = 0.1 - def __init__(self, client, reactor): - config = client.config + def __init__(self, client, config, reactor): smart_routing = config.smart_routing if smart_routing: self._do_invoke = self._invoke_smart diff --git a/hazelcast/lifecycle.py b/hazelcast/lifecycle.py index eeea564856..b1039c7148 100644 --- a/hazelcast/lifecycle.py +++ b/hazelcast/lifecycle.py @@ -84,12 +84,11 @@ def remove_listener(self, registration_id): class _InternalLifecycleService(object): - def __init__(self, client): - self._client = client + def __init__(self, config): self.running = False self._listeners = {} - lifecycle_listeners = client.config.lifecycle_listeners + lifecycle_listeners = config.lifecycle_listeners if lifecycle_listeners: for listener in lifecycle_listeners: self.add_listener(listener) diff --git a/hazelcast/listener.py b/hazelcast/listener.py index b363cbc77a..52b30be923 100644 --- a/hazelcast/listener.py +++ b/hazelcast/listener.py @@ -40,11 +40,11 @@ def __init__(self, server_registration_id, correlation_id): class ListenerService(object): - def __init__(self, client, connection_manager, invocation_service): + def __init__(self, client, config, connection_manager, invocation_service): self._client = client self._connection_manager = connection_manager self._invocation_service = invocation_service - self._is_smart = client.config.smart_routing + self._is_smart = config.smart_routing self._active_registrations = {} # Dict of user_registration_id, ListenerRegistration self._registration_lock = threading.RLock() self._event_handlers = {} diff --git a/hazelcast/near_cache.py b/hazelcast/near_cache.py index b41bf66bbb..1bdc07d132 100644 --- a/hazelcast/near_cache.py +++ b/hazelcast/near_cache.py @@ -261,15 +261,15 @@ def __repr__(self): class NearCacheManager(object): - def __init__(self, client, serialization_service): - self._client = client + def __init__(self, config, serialization_service): + self._config = config self._serialization_service = serialization_service self._caches = {} def get_or_create_near_cache(self, name): near_cache = self._caches.get(name, None) if not near_cache: - near_cache_config = self._client.config.near_caches.get(name, None) + near_cache_config = self._config.near_caches.get(name, None) if not near_cache_config: raise ValueError("Cannot find a near cache configuration with the name '%s'" % name) diff --git a/hazelcast/statistics.py b/hazelcast/statistics.py index 099c4aa9ce..8e4eabf7f0 100644 --- a/hazelcast/statistics.py +++ b/hazelcast/statistics.py @@ -25,13 +25,14 @@ class Statistics(object): _DEFAULT_PROBE_VALUE = 0 - def __init__(self, client, reactor, connection_manager, invocation_service, near_cache_manager): + def __init__( + self, client, config, reactor, connection_manager, invocation_service, near_cache_manager + ): self._client = client self._reactor = reactor self._connection_manager = connection_manager self._invocation_service = invocation_service self._near_cache_manager = near_cache_manager - config = client.config self._enabled = config.statistics_enabled self._period = config.statistics_period self._statistics_timer = None diff --git a/tests/invocation_test.py b/tests/invocation_test.py index 2fbe191705..49b96a02d3 100644 --- a/tests/invocation_test.py +++ b/tests/invocation_test.py @@ -150,8 +150,8 @@ def test_backup_handler_when_all_acks_are_not_received_and_reached_timeout_with_ ) def _start_service(self, config=_Config()): - c = MagicMock(config=config) - invocation_service = InvocationService(c, c._reactor) + c = MagicMock() + invocation_service = InvocationService(c, config, c._reactor) self.service = invocation_service invocation_service.init( c._internal_partition_service, c._connection_manager, c._listener_service diff --git a/tests/proxy/map_nearcache_test.py b/tests/proxy/map_nearcache_test.py index 3f619b5ed5..9f08a59280 100644 --- a/tests/proxy/map_nearcache_test.py +++ b/tests/proxy/map_nearcache_test.py @@ -23,7 +23,7 @@ def configure_client(cls, config): return config def setUp(self): - name = list(self.client.config.near_caches.keys())[0] + name = list(self.client._config.near_caches.keys())[0] self.map = self.client.get_map(name).blocking() def tearDown(self): diff --git a/tests/statistics_test.py b/tests/statistics_test.py index 16166a11d5..846b348733 100644 --- a/tests/statistics_test.py +++ b/tests/statistics_test.py @@ -103,7 +103,7 @@ def test_statistics_content(self): # in different platforms. So, first try to get these statistics and then check the # response content - s = Statistics(client, None, None, None, None) + s = Statistics(client, client._config, None, None, None, None) psutil_stats = s._get_os_and_runtime_stats() for stat_name in psutil_stats: self.assertEqual(1, result.count(stat_name))