cluster: address fallback review feedback

Author: dkropachev

cassandra/cluster.py

@@ -625,15 +625,15 @@ class ControlConnectionQueryFallback(enum.Enum):
     available. Session startup is allowed to proceed even if the initial pool
     attempts all fail.
 
-    ``NoNodePoolFallback`` disables node-pool creation for the session and uses
+    ``SkipPoolCreation`` disables node-pool creation for the session and uses
     the control-connection fallback path for application queries.
 
     The fallback path is not used for requests targeted to an explicit host.
     """
 
     Disabled = "Disabled"
     Fallback = "Fallback"
-    NoNodePoolFallback = "NoNodePoolFallback"
+    SkipPoolCreation = "SkipPoolCreation"
 
 
 class Cluster(object):
@@ -962,7 +962,7 @@ def default_retry_policy(self, policy):
 
     ``Disabled`` keeps the old behavior.
     ``Fallback`` enables control-connection fallback when no usable node pools exist.
-    ``NoNodePoolFallback`` skips node-pool creation and uses the control connection fallback path.
+    ``SkipPoolCreation`` skips node-pool creation and uses the control connection fallback path.
     This fallback is still not used for requests targeted to an explicit host.
     """
 
@@ -2668,7 +2668,7 @@ def __init__(self, cluster, hosts, keyspace=None):
         # create connection pools in parallel
         self._initial_connect_futures = set()
         fallback_mode = self.cluster.allow_control_connection_query_fallback
-        if fallback_mode is not ControlConnectionQueryFallback.NoNodePoolFallback:
+        if fallback_mode is not ControlConnectionQueryFallback.SkipPoolCreation:
             for host in hosts:
                 future = self.add_or_renew_pool(host, is_host_addition=False)
                 if future:
@@ -3283,7 +3283,7 @@ def add_or_renew_pool(self, host, is_host_addition):
         """
         For internal use only.
         """
-        if self.cluster.allow_control_connection_query_fallback is ControlConnectionQueryFallback.NoNodePoolFallback:
+        if self.cluster.allow_control_connection_query_fallback is ControlConnectionQueryFallback.SkipPoolCreation:
             return None
 
         distance = self._profile_manager.distance(host)
@@ -3356,7 +3356,7 @@ def update_created_pools(self):
 
         For internal use only.
         """
-        if self.cluster.allow_control_connection_query_fallback is ControlConnectionQueryFallback.NoNodePoolFallback:
+        if self.cluster.allow_control_connection_query_fallback is ControlConnectionQueryFallback.SkipPoolCreation:
             return set()
 
         futures = set()
@@ -4592,7 +4592,7 @@ def _on_timeout(self, _attempts=0):
                         self._connection.orphaned_threshold_reached = True
 
                 pool.return_connection(self._connection, stream_was_orphaned=True)
-            elif getattr(self._connection, 'is_control_connection', False):
+            elif self._connection.is_control_connection:
                 with self._connection.lock:
                     self._connection.orphaned_request_ids.add(self._req_id)
                     if len(self._connection.orphaned_request_ids) >= self._connection.orphaned_threshold:
@@ -4682,15 +4682,12 @@ def _has_usable_node_pool(self):
         return any(pool and not pool.is_shutdown for pool in pools)
 
     def _fallback_to_control_connection(self):
-        fallback_mode = getattr(
-            self.session.cluster,
-            'allow_control_connection_query_fallback',
-            ControlConnectionQueryFallback.Disabled)
+        fallback_mode = self.session.cluster.allow_control_connection_query_fallback
         if fallback_mode is ControlConnectionQueryFallback.Disabled:
             return False
         if self._host or self._control_connection_query_attempted:
             return False
-        if fallback_mode is ControlConnectionQueryFallback.NoNodePoolFallback:
+        if fallback_mode is ControlConnectionQueryFallback.SkipPoolCreation:
             return True
         return not self._has_usable_node_pool()
 
@@ -4886,7 +4883,7 @@ def start_fetching_next_page(self):
 
     def _reprepare(self, prepare_message, host, connection, pool):
         cb = partial(self.session.submit, self._execute_after_prepare, host, connection, pool)
-        if pool is None and getattr(connection, 'is_control_connection', False):
+        if pool is None and connection.is_control_connection:
             request_id = self._query_control_connection(prepare_message, cb=cb,
                                                         connection=connection, host=host)
         else:
@@ -5110,7 +5107,7 @@ def _execute_after_prepare(self, host, connection, pool, response):
 
                 # use self._query to re-use the same host and
                 # at the same time properly borrow the connection
-                if pool is None and getattr(connection, 'is_control_connection', False):
+                if pool is None and connection.is_control_connection:
                     request_id = self._query_control_connection(connection=connection, host=host)
                 else:
                     request_id = self._query(host)

tests/integration/standard/test_control_connection_query_fallback.py

@@ -98,7 +98,7 @@ def test_fallback_executes_queries_when_broadcast_rpc_address_is_unreachable(sel
 
     def test_no_node_pool_fallback_executes_queries_without_creating_pools(self):
         self.cluster = TestCluster(
-            allow_control_connection_query_fallback=ControlConnectionQueryFallback.NoNodePoolFallback,
+            allow_control_connection_query_fallback=ControlConnectionQueryFallback.SkipPoolCreation,
             connect_timeout=1,
             monitor_reporting_enabled=False,
         )

tests/unit/test_cluster.py

@@ -198,12 +198,12 @@ def test_control_connection_query_fallback_modes(self):
             is ControlConnectionQueryFallback.Fallback
         )
         assert Cluster(
-            allow_control_connection_query_fallback=ControlConnectionQueryFallback.NoNodePoolFallback
-        ).allow_control_connection_query_fallback is ControlConnectionQueryFallback.NoNodePoolFallback
+            allow_control_connection_query_fallback=ControlConnectionQueryFallback.SkipPoolCreation
+        ).allow_control_connection_query_fallback is ControlConnectionQueryFallback.SkipPoolCreation
 
     def test_control_connection_query_fallback_no_node_pool_mode_skips_pool_creation(self):
         cluster = Cluster(
-            allow_control_connection_query_fallback=ControlConnectionQueryFallback.NoNodePoolFallback,
+            allow_control_connection_query_fallback=ControlConnectionQueryFallback.SkipPoolCreation,
             monitor_reporting_enabled=False,
         )
         host = Host("127.0.0.1", SimpleConvictionPolicy, host_id=uuid.uuid4())

tests/unit/test_response_future.py

@@ -452,7 +452,7 @@ def set_keyspace_for_all_pools(keyspace, callback):
 
     def test_control_connection_fallback_when_no_usable_pools(self):
         session = self.make_basic_session()
-        session.cluster.allow_control_connection_query_fallback = ControlConnectionQueryFallback.NoNodePoolFallback
+        session.cluster.allow_control_connection_query_fallback = ControlConnectionQueryFallback.SkipPoolCreation
         session.cluster._default_load_balancing_policy.make_query_plan.return_value = ['ip1', 'ip2']
         session._pools = {}
         connection = self.make_control_connection()