chore(serverless): remove cloud_config option

since scylla-driver is going to remove this configuration option
we are removing it from SCT code

Ref: scylladb/python-driver#590
(cherry picked from commit 0b4a70a)

Author: fruch

docs/configuration_options.md

@@ -1959,15 +1959,6 @@ Defines whether we enable the alternator feature using scylla-operator or not.
 **type:** boolean
 
 
-## **k8s_connection_bundle_file** / SCT_K8S_CONNECTION_BUNDLE_FILE
-
-Serverless configuration bundle file
-
-**default:** N/A
-
-**type:** _file
-
-
 ## **k8s_db_node_service_type** / SCT_K8S_DB_NODE_SERVICE_TYPE
 
 Defines the type of the K8S 'Service' objects type used for ScyllaDB pods. Empty value means 'do not set and allow scylla-operator to choose'.

functional_tests/scylla_operator/test_functional.py

@@ -1004,6 +1004,7 @@ def test_operator_managed_tls(db_cluster: ScyllaPodCluster, tmp_path: path.Path)
         log.debug(output)
 
 
+<<<<<<< HEAD
 @pytest.mark.required_operator("v1.8.0")
 @pytest.mark.requires_tls_and_sni
 def test_cloud_bundle_connectivity_python(db_cluster: ScyllaPodCluster):
@@ -1072,6 +1073,77 @@ def test_cloud_bundle_connectivity_cqlsh(db_cluster: ScyllaPodCluster):
     assert '(1 rows)' in res.stdout
 
 
+||||||| parent of 0b4a70a12 (chore(serverless): remove cloud_config option)
+@pytest.mark.required_operator("v1.8.0")
+@pytest.mark.requires_tls_and_sni
+def test_cloud_bundle_connectivity_python(db_cluster: ScyllaPodCluster):
+
+    assert db_cluster.connection_bundle_file, "cloud bundle wasn't found"
+
+    with db_cluster.cql_connection_patient(db_cluster.nodes[0]) as session:
+        res = session.execute("SELECT * FROM system.local")
+        output = res.all()
+        log.debug(output)
+        assert len(output) == 1
+
+
+@pytest.mark.required_operator("v1.8.0")
+@pytest.mark.requires_tls_and_sni
+def test_cloud_bundle_connectivity_cassandra_stress(tester):
+
+    assert tester.db_cluster.connection_bundle_file, "cloud bundle wasn't found"
+
+    cmd = (
+        """cassandra-stress write cl=ONE duration=1m -schema 'replication(strategy=NetworkTopologyStrategy,replication_factor=1) """
+        """compaction(strategy=SizeTieredCompactionStrategy)' -mode cql3 native """
+        """-rate threads=10 -pop seq=1..10000000 -log interval=5"""
+    )
+
+    stress_obj = tester.run_stress_thread(cmd, stop_test_on_failure=False)
+    output, _ = stress_obj.parse_results()
+
+    assert "latency mean" in output[0]
+    assert float(output[0]["latency mean"]) > 0
+
+    assert "latency 99th percentile" in output[0]
+    assert float(output[0]["latency 99th percentile"]) > 0
+
+
+@pytest.mark.required_operator("v1.8.0")
+@pytest.mark.requires_tls_and_sni
+def test_cloud_bundle_connectivity_scylla_bench(tester):
+
+    assert tester.db_cluster.connection_bundle_file, "cloud bundle wasn't found"
+
+    cmd = (
+        "scylla-bench -workload=sequential -mode=write -replication-factor=1 -partition-count=10 "
+        "-clustering-row-count=5555 -clustering-row-size=uniform:10..20 -concurrency=10 "
+        "-connection-count=10 -consistency-level=one -rows-per-request=10 -timeout=60s -duration=1m"
+    )
+
+    stress_obj = tester.run_stress_thread(cmd, stop_test_on_failure=False)
+    summaries, errors = stress_obj.parse_results()
+    assert not errors
+    assert summaries[0]["Clustering row size"] == "Uniform(min=10, max=20)"
+
+    # TODO: add verification that the output say it's using the cloud bundle
+    #  (need to add that to log output in scylla-bench)
+
+
+@pytest.mark.required_operator("v1.8.0")
+@pytest.mark.requires_tls_and_sni
+def test_cloud_bundle_connectivity_cqlsh(db_cluster: ScyllaPodCluster):
+
+    assert db_cluster.connection_bundle_file, "cloud bundle wasn't found"
+
+    res = db_cluster.nodes[0].run_cqlsh("SELECT * FROM system.local")
+
+    assert not res.stderr
+    assert '(1 rows)' in res.stdout
+
+
+=======
+>>>>>>> 0b4a70a12 (chore(serverless): remove cloud_config option)
 def test_can_recover_from_fatal_pod_termination(db_cluster):
     target_node = db_cluster.nodes[-1]
     experiment = PodFailureExperiment(pod=target_node, duration="60s")

sdcm/cluster.py

@@ -57,7 +57,13 @@
 from cassandra.cluster import Cluster as ClusterDriver
 from cassandra.cluster import NoHostAvailable
 from cassandra.policies import RetryPolicy
+<<<<<<< HEAD
 from cassandra.policies import WhiteListRoundRobinPolicy, HostFilterPolicy, RoundRobinPolicy
+||||||| parent of 0b4a70a12 (chore(serverless): remove cloud_config option)
+from cassandra.policies import WhiteListRoundRobinPolicy, HostFilterPolicy, RoundRobinPolicy, RackAwareRoundRobinPolicy, LoadBalancingPolicy
+=======
+from cassandra.policies import WhiteListRoundRobinPolicy, RackAwareRoundRobinPolicy, LoadBalancingPolicy
+>>>>>>> 0b4a70a12 (chore(serverless): remove cloud_config option)
 from cassandra.query import SimpleStatement
 from argus.common.enums import ResourceState
 from argus.client.sct.types import LogLink
@@ -2874,10 +2880,6 @@ def print_node_running_nemesis(self, node_ip):
 
         return f' ({node.running_nemesis} nemesis target node)' if node.running_nemesis else ' (not target node)'
 
-    @property
-    def is_cqlsh_support_cloud_bundle(self):
-        return bool(self.parent_cluster.connection_bundle_file)
-
     @property
     def is_replacement_by_host_id_supported(self):
         return ComparableScyllaVersion(self.scylla_version) > '5.2.0~dev'
@@ -2899,12 +2901,6 @@ def _gen_cqlsh_cmd(self, command, keyspace, timeout, connect_timeout):
         command = '"{}"'.format(command.strip().replace('"', '\\"'))
 
         cqlsh_cmd = self.add_install_prefix('/usr/bin/cqlsh')
-        if self.is_cqlsh_support_cloud_bundle:
-            connection_bundle_file = self.parent_cluster.connection_bundle_file
-            target_connection_bundle_file = str(Path('/tmp/') / connection_bundle_file.name)
-            self.remoter.send_files(str(connection_bundle_file), target_connection_bundle_file)
-
-            return f'{cqlsh_cmd} {options} -e {command} --cloudconf {target_connection_bundle_file}'
         return f'{cqlsh_cmd} {options} -e {command} {host}'
 
     def run_cqlsh(self, cmd, keyspace=None, timeout=120, verbose=True, split=False, connect_timeout=60,
@@ -3594,7 +3590,7 @@ def create_ssl_context(keyfile: str, certfile: str, truststore: str):
         return ssl_context
 
     def _create_session(self, node, keyspace, user, password, compression, protocol_version, load_balancing_policy=None, port=None,  # noqa: PLR0913
-                        ssl_context=None, node_ips=None, connect_timeout=None, verbose=True, connection_bundle_file=None):
+                        ssl_context=None, node_ips=None, connect_timeout=None, verbose=True):
         if not port:
             port = node.CQL_PORT
 
@@ -3620,8 +3616,6 @@ def _create_session(self, node, keyspace, user, password, compression, protocol_
         self.log.debug("ssl_context: %s", str(ssl_context))
 
         kwargs = dict(contact_points=node_ips, port=port, ssl_context=ssl_context)
-        if connection_bundle_file:
-            kwargs = dict(scylla_cloud=connection_bundle_file)
         cluster_driver = ClusterDriver(auth_provider=auth_provider,
                                        compression=compression,
                                        protocol_version=protocol_version,
@@ -3671,21 +3665,49 @@ def cql_connection(self, node, keyspace=None, user=None,
             - If a connection bundle file is available in the parent cluster, it will be used for the connection.
             - If no connection bundle file is provided, the method will use the WhiteListRoundRobinPolicy with the specified nodes.
         """
+<<<<<<< HEAD
         if connection_bundle_file := node.parent_cluster.connection_bundle_file:
             wlrr = None
             node_ips = []
         else:
             node_ips = self.get_node_cql_ips(nodes=whitelist_nodes)
             wlrr = WhiteListRoundRobinPolicy(node_ips)
+||||||| parent of 0b4a70a12 (chore(serverless): remove cloud_config option)
+        if connection_bundle_file := node.parent_cluster.connection_bundle_file:
+            wlrr = None
+            node_ips = []
+        else:
+            wlrr, node_ips = self.get_load_balancing_policy(whitelist_nodes=whitelist_nodes)
+
+=======
+
+        wlrr, node_ips = self.get_load_balancing_policy(whitelist_nodes=whitelist_nodes)
+>>>>>>> 0b4a70a12 (chore(serverless): remove cloud_config option)
         return self._create_session(node=node, keyspace=keyspace, user=user, password=password, compression=compression,
                                     protocol_version=protocol_version, load_balancing_policy=wlrr, port=port, ssl_context=ssl_context,
-                                    node_ips=node_ips, connect_timeout=connect_timeout, verbose=verbose,
-                                    connection_bundle_file=connection_bundle_file)
+                                    node_ips=node_ips, connect_timeout=connect_timeout, verbose=verbose)
 
     def cql_connection_exclusive(self, node, keyspace=None, user=None,
                                  password=None, compression=True,
                                  protocol_version=None, port=None,
                                  ssl_context=None, connect_timeout=100, verbose=True):
+<<<<<<< HEAD
+        if connection_bundle_file := node.parent_cluster.connection_bundle_file:
+            # TODO: handle the case of multiple datacenters
+            bundle_yaml = yaml.safe_load(connection_bundle_file.open('r', encoding='utf-8'))
+            node_domain = None
+            for _, connection_data in bundle_yaml.get('datacenters', {}).items():
+                node_domain = connection_data.get('nodeDomain').strip()
+            assert node_domain, f"didn't found nodeDomain in bundle [{connection_bundle_file}]"
+
+            def host_filter(host):
+                return str(host.host_id) == str(node.host_id) or node_domain == host.endpoint._server_name
+            wlrr = HostFilterPolicy(child_policy=RoundRobinPolicy(), predicate=host_filter)
+            node_ips = []
+        else:
+            node_ips = [node.cql_address]
+            wlrr = WhiteListRoundRobinPolicy(node_ips)
+||||||| parent of 0b4a70a12 (chore(serverless): remove cloud_config option)
         if connection_bundle_file := node.parent_cluster.connection_bundle_file:
             # TODO: handle the case of multiple datacenters
             bundle_yaml = yaml.safe_load(connection_bundle_file.open('r', encoding='utf-8'))
@@ -3699,12 +3721,21 @@ def host_filter(host):
             wlrr = HostFilterPolicy(child_policy=RoundRobinPolicy(), predicate=host_filter)
             node_ips = []
         else:
+            # Use WhiteListRoundRobinPolicy with a single node IP.
+            # RackAwareRoundRobinPolicy is not applicable for exclusive node connections,
+            # as it operates based on rack and datacenter, not individual nodes.
             node_ips = [node.cql_address]
             wlrr = WhiteListRoundRobinPolicy(node_ips)
+=======
+        # Use WhiteListRoundRobinPolicy with a single node IP.
+        # RackAwareRoundRobinPolicy is not applicable for exclusive node connections,
+        # as it operates based on rack and datacenter, not individual nodes.
+        node_ips = [node.cql_address]
+        wlrr = WhiteListRoundRobinPolicy(node_ips)
+>>>>>>> 0b4a70a12 (chore(serverless): remove cloud_config option)
         return self._create_session(node=node, keyspace=keyspace, user=user, password=password, compression=compression,
                                     protocol_version=protocol_version, load_balancing_policy=wlrr, port=port, ssl_context=ssl_context,
-                                    node_ips=node_ips, connect_timeout=connect_timeout, verbose=verbose,
-                                    connection_bundle_file=connection_bundle_file)
+                                    node_ips=node_ips, connect_timeout=connect_timeout, verbose=verbose)
 
     @retrying(n=8, sleep_time=15, allowed_exceptions=(NoHostAvailable,))
     def cql_connection_patient(self, node, keyspace=None,
@@ -4172,11 +4203,6 @@ def proposed_scylla_yaml(self) -> ScyllaYaml:
         )
         return ScyllaYaml(**cluster_params_builder.dict(exclude_unset=True, exclude_none=True))
 
-    @property
-    def connection_bundle_file(self) -> Path | None:
-        bundle_file = self.params.get("k8s_connection_bundle_file")
-        return Path(bundle_file) if bundle_file else None
-
     @property
     def racks(self) -> Set[int]:
         return {node.rack for node in self.nodes}

sdcm/cluster_k8s/__init__.py

@@ -2683,51 +2683,6 @@ def seed_nodes_addresses(self):
     def seed_nodes(self):
         return []
 
-    @cached_property
-    def connection_bundle_file(self) -> Path | None:
-        if bundle_file := super().connection_bundle_file:
-            return bundle_file
-
-        # TODO: support multiDC case
-        k8s_cluster = self.k8s_clusters[0]
-        bundle_cmd_output = k8s_cluster.kubectl(
-            f"get secret/{self.scylla_cluster_name}-local-cql-connection-configs-admin"
-            f" --template='{{{{ index .data \"{self.scylla_cluster_name}.sct.scylladb.com\" }}}}'",
-            namespace=self.namespace, ignore_status=True)
-
-        if bundle_cmd_output.failed:
-            return None
-
-        fd, file_name = tempfile.mkstemp(suffix='.yaml')
-        os.close(fd)
-        bundle_file = Path(file_name)
-        bundle_file.write_bytes(base64.decodebytes(bytes(bundle_cmd_output.stdout.strip(), encoding='utf-8')))
-
-        lb_external_hostname = k8s_cluster.kubectl(
-            "get service/haproxy-kubernetes-ingress "
-            "-o jsonpath='{.status.loadBalancer.ingress[0].hostname}'",
-            namespace=INGRESS_CONTROLLER_NAMESPACE)
-
-        sni_address = None
-        if not (lb_external_hostname.ok and lb_external_hostname.stdout):
-            lb_cluster_ip = k8s_cluster.kubectl(
-                "get service/haproxy-kubernetes-ingress --template='{{ index .spec.clusterIP }}'",
-                namespace=INGRESS_CONTROLLER_NAMESPACE)
-            if lb_cluster_ip.ok:
-                sni_address = lb_cluster_ip.stdout
-        else:
-            sni_address = lb_external_hostname.stdout
-
-        if sni_address:
-            # TODO: handle the case of multiple datacenters
-            # need to get the cluster ip from each k8s cluster
-            bundle_yaml = yaml.safe_load(bundle_file.open('r', encoding='utf-8'))
-            for _, connection_data in bundle_yaml.get('datacenters', {}).items():
-                connection_data['server'] = f'{sni_address.strip()}:9142'
-            yaml.dump(bundle_yaml, bundle_file.open('w', encoding='utf-8'))
-
-        return bundle_file
-
     def node_setup(self, node: BaseScyllaPodContainer, verbose: bool = False, timeout: int = 3600):
         if self.test_config.BACKTRACE_DECODING:
             node.install_scylla_debuginfo()

sdcm/sct_config.py

@@ -1033,9 +1033,6 @@ class SCTConfiguration(dict):
         dict(name="k8s_enable_alternator", env="SCT_K8S_ENABLE_ALTERNATOR", type=boolean,
              help="Defines whether we enable the alternator feature using scylla-operator or not."),
 
-        dict(name="k8s_connection_bundle_file", env="SCT_K8S_CONNECTION_BUNDLE_FILE", type=_file,
-             help="Serverless configuration bundle file", k8s_multitenancy_supported=True),
-
         # NOTE: following 'k8s_db_node_service_type', 'k8s_db_node_to_node_broadcast_ip_type' and
         #       'k8s_db_node_to_client_broadcast_ip_type' options are supported only starting with
         #       the 'v1.11.0-rc.0' scylla-operator version.

sdcm/scylla_bench_thread.py

@@ -162,27 +162,38 @@ def verify_results(self):
         return sb_summary, errors
 
     def create_stress_cmd(self, stress_cmd, loader, cmd_runner):
+<<<<<<< HEAD
         if self.connection_bundle_file:
             stress_cmd = f'{stress_cmd.strip()} -cloud-config-path={self.target_connection_bundle_file}'
         else:
             # Select first seed node to send the scylla-bench cmds
             ips = ",".join([n.cql_address for n in self.node_list])
             stress_cmd = f'{stress_cmd.strip()} -nodes {ips}'
-
-            if self.params.get("client_encrypt"):
-                for ssl_file in loader.ssl_conf_dir.iterdir():
-                    if ssl_file.is_file():
-                        cmd_runner.send_files(str(ssl_file),
-                                              str(SCYLLA_SSL_CONF_DIR / ssl_file.name),
-                                              verbose=True)
-                stress_cmd = f'{stress_cmd.strip()} -tls -tls-ca-cert-file {SCYLLA_SSL_CONF_DIR}/{TLSAssets.CA_CERT}'
-
-                if self.params.get("peer_verification"):
-                    stress_cmd = f'{stress_cmd.strip()} -tls-host-verification'
-                if self.params.get("client_encrypt_mtls"):
-                    stress_cmd = (
-                        f'{stress_cmd.strip()} -tls-client-key-file {SCYLLA_SSL_CONF_DIR}/{TLSAssets.CLIENT_KEY} '
-                        f'-tls-client-cert-file {SCYLLA_SSL_CONF_DIR}/{TLSAssets.CLIENT_CERT}')
+||||||| parent of 0b4a70a12 (chore(serverless): remove cloud_config option)
+        if self.connection_bundle_file:
+            stress_cmd = f'{stress_cmd.strip()} -cloud-config-path={self.target_connection_bundle_file}'
+        else:
+            # Select first seed node to send the scylla-bench cmds
+            stress_cmd = self.adjust_cmd_node_option(stress_cmd, loader, cmd_runner)
+=======
+        # Select first seed node to send the scylla-bench cmds
+        stress_cmd = self.adjust_cmd_node_option(stress_cmd, loader, cmd_runner)
+>>>>>>> 0b4a70a12 (chore(serverless): remove cloud_config option)
+
+        if self.params.get("client_encrypt"):
+            for ssl_file in loader.ssl_conf_dir.iterdir():
+                if ssl_file.is_file():
+                    cmd_runner.send_files(str(ssl_file),
+                                          str(SCYLLA_SSL_CONF_DIR / ssl_file.name),
+                                          verbose=True)
+            stress_cmd = f'{stress_cmd.strip()} -tls -tls-ca-cert-file {SCYLLA_SSL_CONF_DIR}/{TLSAssets.CA_CERT}'
+
+            if self.params.get("peer_verification"):
+                stress_cmd = f'{stress_cmd.strip()} -tls-host-verification'
+            if self.params.get("client_encrypt_mtls"):
+                stress_cmd = (
+                    f'{stress_cmd.strip()} -tls-client-key-file {SCYLLA_SSL_CONF_DIR}/{TLSAssets.CLIENT_KEY} '
+                    f'-tls-client-cert-file {SCYLLA_SSL_CONF_DIR}/{TLSAssets.CLIENT_CERT}')
 
         return stress_cmd
 
@@ -201,9 +212,6 @@ def _run_stress(self, loader, loader_idx, cpu_idx):
             )
             cmd_runner_name = loader.ip_address
 
-        if self.connection_bundle_file:
-            cmd_runner.send_files(str(self.connection_bundle_file), self.target_connection_bundle_file)
-
         if self.sb_mode == ScyllaBenchModes.WRITE and self.sb_workload == ScyllaBenchWorkloads.TIMESERIES:
             loader.parent_cluster.sb_write_timeseries_ts = write_timestamp = time.time_ns()
             LOGGER.debug("Set start-time: %s", write_timestamp)

sdcm/stress/base.py

@@ -14,7 +14,6 @@
 import logging
 import random
 import concurrent.futures
-from pathlib import Path
 from functools import cached_property
 import uuid
 
@@ -133,14 +132,6 @@ def db_node_to_query(self, loader):
             return node_to_query.cql_address
         return self.node_list[0].cql_address
 
-    @property
-    def connection_bundle_file(self) -> Path:
-        return self.node_list[0].parent_cluster.connection_bundle_file
-
-    @property
-    def target_connection_bundle_file(self) -> str:
-        return str(Path('/tmp/') / self.connection_bundle_file.name)
-
     def configure_event_on_failure(self, stress_event: StressEvent, exc: Exception | Failure):
         error_msg = format_stress_cmd_error(exc)
         if (hasattr(exc, "result") and exc.result.failed) and exc.result.exited == 137: