refactor progress messages setup

Author: xeniape

rust/stackable-cockpit/src/helm.rs

@@ -3,7 +3,8 @@ use std::fmt::Display;
 use serde::{Deserialize, Serialize};
 use snafu::{ResultExt, Snafu};
 use tokio::task::block_in_place;
-use tracing::{debug, error, info, instrument};
+use tracing::{debug, error, info, instrument, Span};
+use tracing_indicatif::span_ext::IndicatifSpanExt as _;
 use url::Url;
 
 use crate::{
@@ -183,7 +184,7 @@ pub struct ChartVersion<'a> {
 ///
 /// This function expects the fully qualified Helm release name. In case of our
 /// operators this is: `<PRODUCT_NAME>-operator`.
-#[instrument(skip(values_yaml), fields(with_values = values_yaml.is_some()))]
+#[instrument(skip(values_yaml), fields(with_values = values_yaml.is_some(), indicatif.pb_show = true))]
 pub fn install_release_from_repo_or_registry(
     release_name: &str,
     ChartVersion {
@@ -199,6 +200,10 @@ pub fn install_release_from_repo_or_registry(
     // but that requires a larger refactoring
     block_in_place(|| {
         debug!("Install Helm release from repo");
+        Span::current().pb_set_message(
+                            format!("Installing {name} Helm chart", name = chart_name)
+                                .as_str(),
+                        );
 
         if check_release_exists(release_name, namespace)? {
             let release = get_release(release_name, namespace)?.ok_or(Error::InstallRelease {
@@ -297,13 +302,14 @@ fn install_release(
 ///
 /// This function expects the fully qualified Helm release name. In case of our
 /// operators this is: `<PRODUCT_NAME>-operator`.
-#[instrument]
+#[instrument(fields(indicatif.pb_show = true))]
 pub fn uninstall_release(
     release_name: &str,
     namespace: &str,
     suppress_output: bool,
 ) -> Result<UninstallReleaseStatus, Error> {
     debug!("Uninstall Helm release");
+    Span::current().pb_set_message(format!("Uninstalling {name}-operator", name = release_name).as_str());
 
     if check_release_exists(release_name, namespace)? {
         let result = helm_sys::uninstall_helm_release(release_name, namespace, suppress_output);

rust/stackable-cockpit/src/lib.rs

@@ -13,12 +13,12 @@ pub mod xfer;
 
 pub static PROGRESS_BAR_STYLE: LazyLock<ProgressStyle> = LazyLock::new(|| {
     ProgressStyle::with_template(
-        "{span_child_prefix_indent}Progress: {wide_bar:.magenta/cyan} {pos}/{len}",
+        "{span_child_prefix}Progress: {wide_bar:.magenta/cyan} {pos}/{len}",
     )
     .expect("valid progress template")
 });
 
 pub static PROGRESS_SPINNER_STYLE: LazyLock<ProgressStyle> = LazyLock::new(|| {
-    ProgressStyle::with_template("{span_child_prefix_indent}{spinner} {msg}")
+    ProgressStyle::with_template("{span_child_prefix}{spinner} {msg}")
         .expect("valid progress template")
 });

rust/stackable-cockpit/src/platform/demo/spec.rs

@@ -1,4 +1,3 @@
-use indicatif::ProgressStyle;
 use serde::{Deserialize, Serialize};
 use snafu::{OptionExt, ResultExt, Snafu};
 use tracing::{Span, debug, info, instrument, warn};
@@ -183,6 +182,7 @@ impl DemoSpec {
         stack_name = %self.stack,
         operator_namespace = %install_params.operator_namespace,
         demo_namespace = %install_params.demo_namespace,
+        indicatif.pb_show = true
     ))]
     async fn prepare_manifests(
         &self,
@@ -191,10 +191,7 @@ impl DemoSpec {
         transfer_client: &xfer::Client,
     ) -> Result<(), Error> {
         info!("Installing demo manifests");
-        Span::current().pb_set_style(
-            &ProgressStyle::with_template("{spinner} Installing manifests")
-                .expect("valid progress template"),
-        );
+        Span::current().pb_set_message("Installing manifests");
 
         let params = install_params
             .parameters

rust/stackable-cockpit/src/platform/manifests.rs

@@ -1,9 +1,8 @@
 use std::collections::HashMap;
 
-use indicatif::ProgressStyle;
 use snafu::{ResultExt, Snafu};
 use stackable_operator::kvp::Labels;
-use tracing::{Instrument as _, Span, debug, info, info_span, instrument};
+use tracing::{Span, debug, info, instrument};
 use tracing_indicatif::span_ext::IndicatifSpanExt as _;
 
 use crate::{
@@ -65,7 +64,7 @@ pub enum Error {
 
 pub trait InstallManifestsExt {
     // TODO (Techassi): This step shouldn't care about templating the manifests nor fetching them from remote
-    #[instrument(skip_all, fields(%namespace))]
+    #[instrument(skip_all, fields(%namespace, indicatif.pb_show = true))]
     #[allow(async_fn_in_trait)]
     async fn install_manifests(
         manifests: &[ManifestSpec],
@@ -86,94 +85,75 @@ pub trait InstallManifestsExt {
         parameters.insert("NAMESPACE".to_owned(), namespace.to_owned());
 
         for manifest in manifests {
-            let span = info_span!("install_manifests_iter");
-
             let parameters = parameters.clone();
             let labels = labels.clone();
-            async move {
-                match manifest {
-                    ManifestSpec::HelmChart(helm_file) => {
-                        debug!(helm_file, "Installing manifest from Helm chart");
-
-                        // Read Helm chart YAML and apply templating
-                        let helm_file =
-                            helm_file.into_path_or_url().context(ParsePathOrUrlSnafu {
-                                path_or_url: helm_file.clone(),
-                            })?;
 
-                        let helm_chart: helm::Chart = transfer_client
-                            .get(&helm_file, &Template::new(&parameters).then(Yaml::new()))
-                            .await
-                            .context(FileTransferSnafu)?;
-
-                        info!(helm_chart.name, helm_chart.version, "Installing Helm chart",);
-                        Span::current().pb_set_message(
-                            format!("Installing {name} Helm chart", name = helm_chart.name)
-                                .as_str(),
-                        );
-                        Span::current().pb_set_style(
-                            &ProgressStyle::with_template("{spinner} {msg}")
-                                .expect("valid progress template"),
-                        );
-
-                        // Assumption: that all manifest helm charts refer to repos not registries
-                        helm::add_repo(&helm_chart.repo.name, &helm_chart.repo.url).context(
-                            AddHelmRepositorySnafu {
-                                repo_name: helm_chart.repo.name.clone(),
-                            },
-                        )?;
-
-                        // Serialize chart options to string
-                        let values_yaml = serde_yaml::to_string(&helm_chart.options)
-                            .context(SerializeOptionsSnafu)?;
-
-                        // Install the Helm chart using the Helm wrapper
-                        helm::install_release_from_repo_or_registry(
-                            &helm_chart.release_name,
-                            helm::ChartVersion {
-                                chart_source: &helm_chart.repo.name,
-                                chart_name: &helm_chart.name,
-                                chart_version: Some(&helm_chart.version),
-                            },
-                            Some(&values_yaml),
-                            namespace,
-                            true,
-                        )
-                        .context(InstallHelmReleaseSnafu {
-                            release_name: helm_chart.release_name,
+            match manifest {
+                ManifestSpec::HelmChart(helm_file) => {
+                    debug!(helm_file, "Installing manifest from Helm chart");
+
+                    // Read Helm chart YAML and apply templating
+                    let helm_file =
+                        helm_file.into_path_or_url().context(ParsePathOrUrlSnafu {
+                            path_or_url: helm_file.clone(),
                         })?;
-                    }
-                    ManifestSpec::PlainYaml(manifest_file) => {
-                        debug!(manifest_file, "Installing YAML manifest");
-                        Span::current().pb_set_style(
-                            &ProgressStyle::with_template("{spinner} Installing YAML manifest")
-                                .expect("valid progress template"),
-                        );
-
-                        // Read YAML manifest and apply templating
-                        let path_or_url =
-                            manifest_file
-                                .into_path_or_url()
-                                .context(ParsePathOrUrlSnafu {
-                                    path_or_url: manifest_file.clone(),
-                                })?;
-
-                        let manifests = transfer_client
-                            .get(&path_or_url, &Template::new(&parameters))
-                            .await
-                            .context(FileTransferSnafu)?;
-
-                        client
-                            .deploy_manifests(&manifests, namespace, labels.clone())
-                            .await
-                            .context(DeployManifestSnafu)?;
-                    }
+
+                    let helm_chart: helm::Chart = transfer_client
+                        .get(&helm_file, &Template::new(&parameters).then(Yaml::new()))
+                        .await
+                        .context(FileTransferSnafu)?;
+
+                    info!(helm_chart.name, helm_chart.version, "Installing Helm chart",);
+
+                    // Assumption: that all manifest helm charts refer to repos not registries
+                    helm::add_repo(&helm_chart.repo.name, &helm_chart.repo.url).context(
+                        AddHelmRepositorySnafu {
+                            repo_name: helm_chart.repo.name.clone(),
+                        },
+                    )?;
+
+                    // Serialize chart options to string
+                    let values_yaml = serde_yaml::to_string(&helm_chart.options)
+                        .context(SerializeOptionsSnafu)?;
+
+                    // Install the Helm chart using the Helm wrapper
+                    helm::install_release_from_repo_or_registry(
+                        &helm_chart.release_name,
+                        helm::ChartVersion {
+                            chart_source: &helm_chart.repo.name,
+                            chart_name: &helm_chart.name,
+                            chart_version: Some(&helm_chart.version),
+                        },
+                        Some(&values_yaml),
+                        namespace,
+                        true,
+                    )
+                    .context(InstallHelmReleaseSnafu {
+                        release_name: helm_chart.release_name,
+                    })?;
                 }
+                ManifestSpec::PlainYaml(manifest_file) => {
+                    debug!(manifest_file, "Installing YAML manifest");
+
+                    // Read YAML manifest and apply templating
+                    let path_or_url =
+                        manifest_file
+                            .into_path_or_url()
+                            .context(ParsePathOrUrlSnafu {
+                                path_or_url: manifest_file.clone(),
+                            })?;
+
+                    let manifests = transfer_client
+                        .get(&path_or_url, &Template::new(&parameters))
+                        .await
+                        .context(FileTransferSnafu)?;
 
-                Ok::<(), Error>(())
+                    client
+                        .deploy_manifests(&manifests, namespace, labels.clone())
+                        .await
+                        .context(DeployManifestSnafu)?;
+                }
             }
-            .instrument(span)
-            .await?;
 
             Span::current().pb_inc(1);
         }

rust/stackable-cockpit/src/platform/operator/mod.rs

@@ -1,6 +1,5 @@
 use std::{fmt::Display, str::FromStr};
 
-use indicatif::ProgressStyle;
 use semver::Version;
 use serde::Serialize;
 use snafu::{ResultExt, Snafu, ensure};
@@ -186,6 +185,7 @@ impl OperatorSpec {
         // display for the inner type if it exists. Otherwise we gte the Debug
         // impl for the whole Option.
         version = self.version.as_ref().map(tracing::field::display),
+        indicatif.pb_show = true
     ))]
     pub fn install(
         &self,
@@ -195,9 +195,6 @@ impl OperatorSpec {
         info!(operator = %self, "Installing operator");
         Span::current()
             .pb_set_message(format!("Installing {name}-operator", name = self.name).as_str());
-        Span::current().pb_set_style(
-            &ProgressStyle::with_template("{spinner} {msg}").expect("valid progress template"),
-        );
 
         let version = self.version.as_ref().map(|v| v.to_string());
         let helm_name = self.helm_name();

rust/stackable-cockpit/src/platform/release/spec.rs

@@ -54,6 +54,7 @@ impl ReleaseSpec {
         %namespace,
         product.included = tracing::field::Empty,
         product.excluded = tracing::field::Empty,
+        indicatif.pb_show = true
     ))]
     pub async fn install(
         &self,
@@ -117,7 +118,7 @@ impl ReleaseSpec {
             .await
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(indicatif.pb_show = true))]
     pub fn uninstall(&self, namespace: &str) -> Result<()> {
         info!("Uninstalling release");
 

rust/stackable-cockpit/src/platform/stack/spec.rs

@@ -1,4 +1,3 @@
-use indicatif::ProgressStyle;
 use serde::{Deserialize, Serialize};
 use snafu::{OptionExt, ResultExt, Snafu};
 use tracing::{Span, debug, info, instrument, log::warn};
@@ -196,7 +195,7 @@ impl StackSpec {
             .await
     }
 
-    #[instrument(skip_all, fields(release = %self.release, %operator_namespace))]
+    #[instrument(skip_all, fields(release = %self.release, %operator_namespace, indicatif.pb_show = true))]
     pub async fn install_release(
         &self,
         release_list: release::ReleaseList,
@@ -205,10 +204,7 @@ impl StackSpec {
         chart_source: &ChartSourceType,
     ) -> Result<(), Error> {
         info!(self.release, "Trying to install release");
-        Span::current().pb_set_style(
-            &ProgressStyle::with_template("{spinner} Installing operators")
-                .expect("valid progress template"),
-        );
+        Span::current().pb_set_message("Installing operators");
 
         // Get the release by name
         let release = release_list
@@ -224,18 +220,15 @@ impl StackSpec {
             .context(InstallReleaseSnafu)
     }
 
-    #[instrument(skip_all)]
+    #[instrument(skip_all, fields(indicatif.pb_show = true))]
     pub async fn prepare_manifests(
         &self,
         install_params: StackInstallParameters,
         client: &Client,
         transfer_client: &xfer::Client,
     ) -> Result<(), Error> {
         info!("Installing stack manifests");
-        Span::current().pb_set_style(
-            &ProgressStyle::with_template("{spinner} Installing manifests")
-                .expect("valid progress template"),
-        );
+        Span::current().pb_set_message("Installing manifests");
 
         let parameters = install_params
             .parameters

rust/stackable-cockpit/src/utils/k8s/client.rs

@@ -14,7 +14,8 @@ use serde::Deserialize;
 use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{commons::listener::Listener, kvp::Labels};
 use tokio::sync::RwLock;
-use tracing::info;
+use tracing::{info, instrument, Span};
+use tracing_indicatif::span_ext::IndicatifSpanExt as _;
 
 #[cfg(doc)]
 use crate::utils::k8s::ListParamsExt;
@@ -98,12 +99,15 @@ impl Client {
     /// Deploys manifests defined the in raw `manifests` YAML string. This
     /// method will fail if it is unable to parse the manifests, unable to
     /// resolve GVKs or unable to patch the dynamic objects.
+    #[instrument(skip_all, fields(indicatif.pb_show = true))]
     pub async fn deploy_manifests(
         &self,
         manifests: &str,
         namespace: &str,
         labels: Labels,
     ) -> Result<()> {
+        Span::current().pb_set_message("Installing YAML manifest");
+
         // TODO (Techassi): Impl IntoIterator for Labels
         let labels: BTreeMap<String, String> = labels.into();