ccm: add support for updateconf

Author: muzarski

scylla/tests/ccm_integration/ccm/cluster.rs

@@ -263,6 +263,56 @@ impl Node {
         env
     }
 
+    /// Executes `ccm updateconf` and applies it for this node.
+    /// It accepts the key-value pairs to update the configuration.
+    ///
+    /// ### Example
+    /// ```
+    /// # use crate::ccm::cluster::Node;
+    /// # async fn check_only_compiles(node: &Node) -> Result<(), Box<dyn Error>> {
+    /// let args = [
+    ///     ("client_encryption_options.enabled", "true"),
+    ///     ("client_encryption_options.certificate", "db.cert"),
+    ///     ("client_encryption_options.keyfile", "db.key"),
+    /// ];
+    ///
+    /// node.updateconf(args).await?
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// The code above is equivalent to the following scylla.yaml:
+    /// ```yaml
+    /// client_encryption_options:
+    ///   enabled: true
+    ///   certificate: db.cert
+    ///   keyfile: db.key
+    /// ```
+    pub(crate) async fn updateconf<K, V>(
+        &self,
+        key_values: impl IntoIterator<Item = (K, V)>,
+    ) -> Result<(), Error>
+    where
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        let config_dir = &self.config_dir;
+        let mut args: Vec<String> = vec![
+            self.opts.name(),
+            "updateconf".to_string(),
+            "--config-dir".to_string(),
+            config_dir.to_string_lossy().into_owned(),
+        ];
+        for (k, v) in key_values.into_iter() {
+            args.push(format!("{}:{}", k.as_ref(), v.as_ref()));
+        }
+
+        self.logged_cmd
+            .run_command("ccm", &args, RunOptions::new())
+            .await?;
+        Ok(())
+    }
+
     /// This method starts the node. User can provide optional [`NodeStartOptions`] to control the behavior of the node start.
     /// If `None` is provided, the default options are used (see the implementation of Default for [`NodeStartOptions`]).
     pub(crate) async fn start(&mut self, opts: Option<NodeStartOptions>) -> Result<(), Error> {
@@ -580,6 +630,55 @@ impl Cluster {
         Ok(())
     }
 
+    /// Executes `ccm updateconf` and applies it for all nodes in the cluster.
+    /// It accepts the key-value pairs to update the configuration.
+    ///
+    /// ### Example
+    /// ```
+    /// # use crate::ccm::cluster::Cluster;
+    /// # async fn check_only_compiles(cluster: &Cluster) -> Result<(), Box<dyn Error>> {
+    /// let args = [
+    ///     ("client_encryption_options.enabled", "true"),
+    ///     ("client_encryption_options.certificate", "db.cert"),
+    ///     ("client_encryption_options.keyfile", "db.key"),
+    /// ];
+    ///
+    /// cluster.updateconf(args).await?
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// The code above is equivalent to the following scylla.yaml:
+    /// ```yaml
+    /// client_encryption_options:
+    ///   enabled: true
+    ///   certificate: db.cert
+    ///   keyfile: db.key
+    /// ```
+    pub(crate) async fn updateconf<K, V>(
+        &self,
+        key_values: impl IntoIterator<Item = (K, V)>,
+    ) -> Result<(), Error>
+    where
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        let config_dir = self.config_dir();
+        let mut args: Vec<String> = vec![
+            "updateconf".to_string(),
+            "--config-dir".to_string(),
+            config_dir.to_string_lossy().into_owned(),
+        ];
+        for (k, v) in key_values.into_iter() {
+            args.push(format!("{}:{}", k.as_ref(), v.as_ref()));
+        }
+
+        self.logged_cmd
+            .run_command("ccm", &args, RunOptions::new())
+            .await?;
+        Ok(())
+    }
+
     fn get_ccm_env(&self) -> HashMap<String, String> {
         let mut env: HashMap<String, String> = HashMap::new();
         env.insert(

scylla/tests/ccm_integration/ccm/mod.rs

@@ -81,3 +81,58 @@ where
     test_body(Arc::clone(&wrapper.0)).await;
     std::mem::drop(wrapper);
 }
+
+/// Run a CCM test with a custom configuration logic before the cluster starts.
+///
+/// ### Example
+/// ```
+/// # use crate::ccm::cluster::Cluster;
+/// # use crate::ccm::run_ccm_test_with_configuration;
+/// # use std::sync::{Arc, Mutex};
+/// async fn configure_cluster(cluster: Cluster) -> Cluster {
+///    // Do some configuration here
+///    cluster.updateconf([("foo", "bar")]).await.expect("failed to update conf");
+///    cluster
+/// }
+///
+/// async fn test(cluster: Arc<Mutex<Cluster>>) {
+///     let cluster = cluster.lock().await;
+///     let session = cluster.make_session_builder().await.build().await.unwrap();
+///
+///     println!("Succesfully connected to the cluster!");
+/// }
+///
+/// run_ccm_test_with_configuration(ClusterOptions::default, configure_cluster, test).await;
+/// ```
+pub(crate) async fn run_ccm_test_with_configuration<C, Conf, ConfFut, T, TFut>(
+    make_cluster_options: C,
+    configure: Conf,
+    test_body: T,
+) where
+    C: FnOnce() -> ClusterOptions,
+    Conf: FnOnce(Cluster) -> ConfFut,
+    ConfFut: Future<Output = Cluster>,
+    T: FnOnce(Arc<tokio::sync::Mutex<Cluster>>) -> TFut,
+    TFut: Future<Output = ()>,
+{
+    let cluster_options = make_cluster_options();
+    let mut cluster = Cluster::new(cluster_options)
+        .await
+        .expect("Failed to create cluster");
+    cluster.init().await.expect("failed to initialize cluster");
+    cluster = configure(cluster).await;
+    cluster.start(None).await.expect("failed to start cluster");
+
+    struct ClusterWrapper(Arc<tokio::sync::Mutex<Cluster>>);
+    impl Drop for ClusterWrapper {
+        fn drop(&mut self) {
+            if std::thread::panicking() && *TEST_KEEP_CLUSTER_ON_FAILURE {
+                println!("Test failed, keep cluster alive, TEST_KEEP_CLUSTER_ON_FAILURE=true");
+                self.0.blocking_lock().set_keep_on_drop(true);
+            }
+        }
+    }
+    let wrapper = ClusterWrapper(Arc::new(tokio::sync::Mutex::new(cluster)));
+    test_body(Arc::clone(&wrapper.0)).await;
+    std::mem::drop(wrapper);
+}