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/pytest.ini

@@ -4,7 +4,6 @@ markers =
     requires_mgmt: test requires scylla manager to exist, set "use_mgmt: true" to enable it
     requires_backend: used for the specification of supported backends and making a test be skipped if there is not match
     requires_scylla_versions: test will be skipped if the installed Scylla version doesn't match values of this marker
-    requires_tls_and_sni: test will be skipped if the TLS+SNI features are not enabled
     required_operator: test will be skipped if the installed Scylla-Operator version doesn't match values of this marker
     readonly: test that does not make any changes to cluster, only reads. Useful for running fast subset of tests
     restart_is_used: used for skipping tests which suffer from https://github.com/scylladb/scylla/issues/9543

functional_tests/scylla_operator/test_functional.py

@@ -1004,74 +1004,6 @@ def test_operator_managed_tls(db_cluster: ScyllaPodCluster, tmp_path: path.Path)
         log.debug(output)
 
 
-@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.get_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.verify_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
-
-
 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,7 @@
 from cassandra.cluster import Cluster as ClusterDriver
 from cassandra.cluster import NoHostAvailable
 from cassandra.policies import RetryPolicy
-from cassandra.policies import WhiteListRoundRobinPolicy, HostFilterPolicy, RoundRobinPolicy
+from cassandra.policies import WhiteListRoundRobinPolicy
 from cassandra.query import SimpleStatement
 from argus.common.enums import ResourceState
 from argus.client.sct.types import LogLink
@@ -2874,10 +2874,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 +2895,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 +3584,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 +3610,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,40 +3659,23 @@ 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.
         """
-        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)
+        node_ips = self.get_node_cql_ips(nodes=whitelist_nodes)
+        wlrr = WhiteListRoundRobinPolicy(node_ips)
+
         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):
-        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)
+
+        node_ips = [node.cql_address]
+        wlrr = WhiteListRoundRobinPolicy(node_ips)
         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 +4143,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,24 @@ def verify_results(self):
         return sb_summary, errors
 
     def create_stress_cmd(self, stress_cmd, loader, cmd_runner):
-        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}')
+        # 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}')
 
         return stress_cmd
 
@@ -201,9 +198,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:

sdcm/stress_thread.py

@@ -18,7 +18,6 @@
 import contextlib
 from typing import Any
 from itertools import chain
-from pathlib import Path
 
 from sdcm.db_stats import get_stress_cmd_params
 from sdcm.loader import CassandraStressExporter, CassandraStressHDRExporter
@@ -171,10 +170,7 @@ def adjust_cmd_node_option(self, stress_cmd, loader, cmd_runner):
         return stress_cmd
 
     def adjust_cmd_connection_options(self, stress_cmd: str, loader, cmd_runner) -> str:
-        if (connection_bundle_file := self.node_list[0].parent_cluster.connection_bundle_file) and '-node' not in stress_cmd:
-            stress_cmd += f" -cloudconf file={Path('/tmp') / connection_bundle_file.name}"
-        else:
-            stress_cmd = self.adjust_cmd_node_option(stress_cmd, loader, cmd_runner)
+        stress_cmd = self.adjust_cmd_node_option(stress_cmd, loader, cmd_runner)
         return stress_cmd
 
     def create_stress_cmd(self, cmd_runner, keyspace_idx, loader):
@@ -326,10 +322,6 @@ def _run_cs_stress(self, loader, loader_idx, cpu_idx, keyspace_idx):  # noqa: PL
                                           str(SCYLLA_SSL_CONF_DIR / ssl_file.name),
                                           verbose=True)
 
-        if connection_bundle_file := self.connection_bundle_file:
-            cmd_runner.send_files(str(connection_bundle_file),
-                                  self.target_connection_bundle_file, delete_dst=True, verbose=True)
-
         if self.params.get("use_hdrhistogram"):
             stress_cmd = self._add_hdr_log_option(stress_cmd, remote_hdr_file_name)
             hdrh_logger_context = HDRHistogramFileLogger(