Remove protocol v1/v2 - additional removals

Remove additional getters and setters that only make sense for V1/V2 protocols.

Signed-off-by: Yaniv Kaul <[email protected]>

Author: mykaul

cassandra/cluster.py

@@ -1666,31 +1666,6 @@ def get_core_connections_per_host(self, host_distance):
         """
         return self._core_connections_per_host[host_distance]
 
-    def set_core_connections_per_host(self, host_distance, core_connections):
-        """
-        Sets the minimum number of connections per Session that will be opened
-        for each host with :class:`~.HostDistance` equal to `host_distance`.
-        The default is 2 for :attr:`~HostDistance.LOCAL` and 1 for
-        :attr:`~HostDistance.REMOTE`.
-
-        Protocol version 1 and 2 are limited in the number of concurrent
-        requests they can send per connection. The driver implements connection
-        pooling to support higher levels of concurrency.
-
-        If :attr:`~.Cluster.protocol_version` is set to 3 or higher, this
-        is not supported (there is always one connection per host, unless
-        the host is remote and :attr:`connect_to_remote_hosts` is :const:`False`)
-        and using this will result in an :exc:`~.UnsupportedOperation`.
-        """
-        if self.protocol_version >= 3:
-            raise UnsupportedOperation(
-                "Cluster.set_core_connections_per_host() only has an effect "
-                "when using protocol_version 1 or 2.")
-        old = self._core_connections_per_host[host_distance]
-        self._core_connections_per_host[host_distance] = core_connections
-        if old < core_connections:
-            self._ensure_core_connections()
-
     def get_max_connections_per_host(self, host_distance):
         """
         Gets the maximum number of connections per Session that will be opened
@@ -1703,24 +1678,6 @@ def get_max_connections_per_host(self, host_distance):
         """
         return self._max_connections_per_host[host_distance]
 
-    def set_max_connections_per_host(self, host_distance, max_connections):
-        """
-        Sets the maximum number of connections per Session that will be opened
-        for each host with :class:`~.HostDistance` equal to `host_distance`.
-        The default is 2 for :attr:`~HostDistance.LOCAL` and 1 for
-        :attr:`~HostDistance.REMOTE`.
-
-        If :attr:`~.Cluster.protocol_version` is set to 3 or higher, this
-        is not supported (there is always one connection per host, unless
-        the host is remote and :attr:`connect_to_remote_hosts` is :const:`False`)
-        and using this will result in an :exc:`~.UnsupportedOperation`.
-        """
-        if self.protocol_version >= 3:
-            raise UnsupportedOperation(
-                "Cluster.set_max_connections_per_host() only has an effect "
-                "when using protocol_version 1 or 2.")
-        self._max_connections_per_host[host_distance] = max_connections
-
     def connection_factory(self, endpoint, host_conn = None, *args, **kwargs):
         """
         Called to create a new connection with proper configuration.
@@ -2238,15 +2195,6 @@ def listeners(self):
         with self._listener_lock:
             return self._listeners.copy()
 
-    def _ensure_core_connections(self):
-        """
-        If any host has fewer than the configured number of core connections
-        open, attempt to open connections until that number is met.
-        """
-        for session in tuple(self.sessions):
-            for pool in tuple(session._pools.values()):
-                pool.ensure_core_connections()
-
     @staticmethod
     def _validate_refresh_schema(keyspace, table, usertype, function, aggregate):
         if any((table, usertype, function, aggregate)):

cassandra/concurrent.py

@@ -33,13 +33,7 @@ def execute_concurrent(session, statements_and_parameters, concurrency=100, rais
     ``parameters`` item must be a sequence or :const:`None`.
 
     The `concurrency` parameter controls how many statements will be executed
-    concurrently.  When :attr:`.Cluster.protocol_version` is set to 1 or 2,
-    it is recommended that this be kept below 100 times the number of
-    core connections per host times the number of connected hosts (see
-    :meth:`.Cluster.set_core_connections_per_host`).  If that amount is exceeded,
-    the event loop thread may attempt to block on new connection creation,
-    substantially impacting throughput.  If :attr:`~.Cluster.protocol_version`
-    is 3 or higher, you can safely experiment with higher levels of concurrency.
+    concurrently.
 
     If `raise_on_first_error` is left as :const:`True`, execution will stop
     after the first failed statement and the corresponding exception will be

cassandra/pool.py

@@ -1234,17 +1234,6 @@ def shutdown(self):
         for conn in connections_to_close:
             conn.close()
 
-    def ensure_core_connections(self):
-        if self.is_shutdown:
-            return
-
-        core_conns = self._session.cluster.get_core_connections_per_host(self.host_distance)
-        with self._lock:
-            to_create = core_conns - (len(self._connections) + self._scheduled_for_creation)
-            for i in range(to_create):
-                self._scheduled_for_creation += 1
-                self._session.submit(self._create_new_connection)
-
     def _set_keyspace_for_all_conns(self, keyspace, callback):
         """
         Asynchronously sets the keyspace for all connections.  When all

docs/api/cassandra/cluster.rst

@@ -88,12 +88,8 @@
 
    .. automethod:: get_core_connections_per_host
 
-   .. automethod:: set_core_connections_per_host
-
    .. automethod:: get_max_connections_per_host
 
-   .. automethod:: set_max_connections_per_host
-
    .. automethod:: get_control_connection_host
 
    .. automethod:: refresh_schema_metadata

tests/integration/standard/test_authentication.py

@@ -62,18 +62,12 @@ class AuthenticationTests(unittest.TestCase):
     def get_authentication_provider(self, username, password):
         """
         Return correct authentication provider based on protocol version.
-        There is a difference in the semantics of authentication provider argument with protocol versions 1 and 2
         For protocol version 2 and higher it should be a PlainTextAuthProvider object.
-        For protocol version 1 it should be a function taking hostname as an argument and returning a dictionary
-        containing username and password.
         :param username: authentication username
         :param password: authentication password
         :return: authentication object suitable for Cluster.connect()
         """
-        if PROTOCOL_VERSION < 2:
-            return lambda hostname: dict(username=username, password=password)
-        else:
-            return PlainTextAuthProvider(username=username, password=password)
+        return PlainTextAuthProvider(username=username, password=password)
 
     def cluster_as(self, usr, pwd):
         # test we can connect at least once with creds

tests/integration/standard/test_cluster.py

@@ -728,8 +728,6 @@ def test_idle_heartbeat(self):
         interval = 2
         cluster = TestCluster(idle_heartbeat_interval=interval,
                               monitor_reporting_enabled=False)
-        if PROTOCOL_VERSION < 3:
-            cluster.set_core_connections_per_host(HostDistance.LOCAL, 1)
         session = cluster.connect(wait_for_all_pools=True)
 
         # This test relies on impl details of connection req id management to see if heartbeats

tests/integration/standard/test_concurrent.py

@@ -45,8 +45,6 @@ def setUpClass(cls):
                 EXEC_PROFILE_DICT: ExecutionProfile(row_factory=dict_factory)
             }
         )
-        if PROTOCOL_VERSION < 3:
-            cls.cluster.set_core_connections_per_host(HostDistance.LOCAL, 1)
         cls.session = cls.cluster.connect()
 
     @classmethod

tests/integration/standard/test_query.py

@@ -665,8 +665,6 @@ def setUp(self):
                 % (PROTOCOL_VERSION,))
 
         self.cluster = TestCluster()
-        if PROTOCOL_VERSION < 3:
-            self.cluster.set_core_connections_per_host(HostDistance.LOCAL, 1)
         self.session = self.cluster.connect(wait_for_all_pools=True)
 
     def tearDown(self):
@@ -796,8 +794,6 @@ def setUp(self):
                 % (PROTOCOL_VERSION,))
 
         self.cluster = TestCluster()
-        if PROTOCOL_VERSION < 3:
-            self.cluster.set_core_connections_per_host(HostDistance.LOCAL, 1)
         self.session = self.cluster.connect()
 
     def tearDown(self):

tests/integration/standard/test_query_paging.py

@@ -43,8 +43,6 @@ def setUp(self):
         self.cluster = TestCluster(
             execution_profiles={EXEC_PROFILE_DEFAULT: ExecutionProfile(consistency_level=ConsistencyLevel.LOCAL_QUORUM)}
         )
-        if PROTOCOL_VERSION < 3:
-            self.cluster.set_core_connections_per_host(HostDistance.LOCAL, 1)
         self.session = self.cluster.connect(wait_for_all_pools=True)
         self.session.execute("TRUNCATE test3rf.test")
 

tests/integration/util.py

@@ -53,5 +53,3 @@ def assert_quiescent_pool_state(test_case, cluster, wait=None):
             test_case.assertEqual(len(req_ids), len(set(req_ids)))
             test_case.assertEqual(connection.highest_request_id, len(req_ids) + len(orphan_ids) - 1)
             test_case.assertEqual(connection.highest_request_id, max(chain(req_ids, orphan_ids)))
-            if PROTOCOL_VERSION < 3:
-                test_case.assertEqual(connection.highest_request_id, connection.max_request_id)