Store cluster domain in separate KubernetesClusterInfo struct

Author: sbernauer

crates/stackable-operator/src/cli.rs

@@ -115,7 +115,7 @@ use clap::Args;
 use product_config::ProductConfigManager;
 use snafu::{ResultExt, Snafu};
 
-use crate::{logging::TracingTarget, namespace::WatchNamespace};
+use crate::{commons::networking::DomainName, logging::TracingTarget, namespace::WatchNamespace};
 
 pub const AUTHOR: &str = "Stackable GmbH - [email protected]";
 
@@ -179,7 +179,8 @@ pub enum Command<Run: Args = ProductOperatorRun> {
 ///     common: ProductOperatorRun {
 ///         product_config: ProductConfigPath::from("bar".as_ref()),
 ///         watch_namespace: WatchNamespace::One("foobar".to_string()),
-///         tracing_target: TracingTarget::None
+///         tracing_target: TracingTarget::None,
+///         kubernetes_cluster_domain: None,
 ///     },
 /// }));
 /// ```
@@ -205,12 +206,20 @@ pub struct ProductOperatorRun {
     /// Provides the path to a product-config file
     #[arg(long, short = 'p', value_name = "FILE", default_value = "", env)]
     pub product_config: ProductConfigPath,
+
     /// Provides a specific namespace to watch (instead of watching all namespaces)
     #[arg(long, env, default_value = "")]
     pub watch_namespace: WatchNamespace,
+
     /// Tracing log collector system
     #[arg(long, env, default_value_t, value_enum)]
     pub tracing_target: TracingTarget,
+
+    /// Kubernetes cluster domain, usually this is `cluster.local`.
+    // We are not using a default value here, as operators will probably do an more advanced
+    // auto-detection of the cluster domain in case it is not specified in the future.
+    #[arg(long, env)]
+    pub kubernetes_cluster_domain: Option<DomainName>,
 }
 
 /// A path to a [`ProductConfigManager`] spec file
@@ -384,6 +393,7 @@ mod tests {
                 product_config: ProductConfigPath::from("bar".as_ref()),
                 watch_namespace: WatchNamespace::One("foo".to_string()),
                 tracing_target: TracingTarget::None,
+                kubernetes_cluster_domain: None,
             }
         );
 
@@ -395,6 +405,7 @@ mod tests {
                 product_config: ProductConfigPath::from("bar".as_ref()),
                 watch_namespace: WatchNamespace::All,
                 tracing_target: TracingTarget::None,
+                kubernetes_cluster_domain: None,
             }
         );
 
@@ -407,6 +418,7 @@ mod tests {
                 product_config: ProductConfigPath::from("bar".as_ref()),
                 watch_namespace: WatchNamespace::One("foo".to_string()),
                 tracing_target: TracingTarget::None,
+                kubernetes_cluster_domain: None,
             }
         );
     }

crates/stackable-operator/src/client.rs

@@ -1,24 +1,28 @@
-use crate::commons::networking::DomainName;
-use crate::kvp::LabelSelectorExt;
-use crate::utils::cluster_domain::{self, retrieve_cluster_domain};
+use std::{
+    convert::TryFrom,
+    fmt::{Debug, Display},
+};
 
 use either::Either;
 use futures::StreamExt;
-use k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector;
-use k8s_openapi::{ClusterResourceScope, NamespaceResourceScope};
-use kube::api::{DeleteParams, ListParams, Patch, PatchParams, PostParams, Resource, ResourceExt};
-use kube::client::Client as KubeClient;
-use kube::core::Status;
-use kube::runtime::wait::delete::delete_and_finalize;
-use kube::runtime::{watcher, WatchStreamExt};
-use kube::{Api, Config};
-use serde::de::DeserializeOwned;
-use serde::Serialize;
+use k8s_openapi::{
+    apimachinery::pkg::apis::meta::v1::LabelSelector, ClusterResourceScope, NamespaceResourceScope,
+};
+use kube::{
+    api::{DeleteParams, ListParams, Patch, PatchParams, PostParams, Resource, ResourceExt},
+    client::Client as KubeClient,
+    core::Status,
+    runtime::{wait::delete::delete_and_finalize, watcher, WatchStreamExt},
+    Api, Config,
+};
+use serde::{de::DeserializeOwned, Serialize};
 use snafu::{OptionExt, ResultExt, Snafu};
-use std::convert::TryFrom;
-use std::fmt::{Debug, Display};
 use tracing::trace;
 
+use crate::{
+    cli::ProductOperatorRun, kvp::LabelSelectorExt, utils::cluster_info::KubernetesClusterInfo,
+};
+
 pub type Result<T, E = Error> = std::result::Result<T, E>;
 
 #[derive(Debug, Snafu)]
@@ -79,9 +83,6 @@ pub enum Error {
 
     #[snafu(display("unable to create kubernetes client"))]
     CreateKubeClient { source: kube::Error },
-
-    #[snafu(display("unable to to resolve kubernetes cluster domain"))]
-    ResolveKubernetesClusterDomain { source: cluster_domain::Error },
 }
 
 /// This `Client` can be used to access Kubernetes.
@@ -94,15 +95,16 @@ pub struct Client {
     delete_params: DeleteParams,
     /// Default namespace as defined in the kubeconfig this client has been created from.
     pub default_namespace: String,
-    pub kubernetes_cluster_domain: DomainName,
+
+    pub kubernetes_cluster_info: KubernetesClusterInfo,
 }
 
 impl Client {
     pub fn new(
         client: KubeClient,
         field_manager: Option<String>,
         default_namespace: String,
-        kubernetes_cluster_domain: DomainName,
+        kubernetes_cluster_info: KubernetesClusterInfo,
     ) -> Self {
         Client {
             client,
@@ -116,7 +118,7 @@ impl Client {
             },
             delete_params: DeleteParams::default(),
             default_namespace,
-            kubernetes_cluster_domain,
+            kubernetes_cluster_info,
         }
     }
 
@@ -515,15 +517,18 @@ impl Client {
     ///
     /// ```no_run
     /// use std::time::Duration;
+    /// use clap::Parser;
     /// use tokio::time::error::Elapsed;
     /// use kube::runtime::watcher;
     /// use k8s_openapi::api::core::v1::Pod;
-    /// use stackable_operator::client::{Client, initialize_operator};
+    /// use stackable_operator::{cli::ProductOperatorRun, client::{Client, initialize_operator}};
     ///
     /// #[tokio::main]
     /// async fn main(){
     ///
-    /// let client: Client = initialize_operator(None).await.expect("Unable to construct client.");
+    /// // Parse CLI arguments with Opts::parse() instead
+    /// let cli_opts = ProductOperatorRun::parse_from(["run"]);
+    /// let client: Client = initialize_operator(&cli_opts, None).await.expect("Unable to construct client.");
     /// let watcher_config: watcher::Config =
     ///         watcher::Config::default().fields(&format!("metadata.name=nonexistent-pod"));
     ///
@@ -630,39 +635,49 @@ where
     }
 }
 
-pub async fn initialize_operator(field_manager: Option<String>) -> Result<Client> {
+pub async fn initialize_operator(
+    cli_opts: &ProductOperatorRun,
+    field_manager: Option<String>,
+) -> Result<Client> {
     let kubeconfig: Config = kube::Config::infer()
         .await
         .map_err(kube::Error::InferConfig)
         .context(InferKubeConfigSnafu)?;
     let default_namespace = kubeconfig.default_namespace.clone();
     let client = kube::Client::try_from(kubeconfig).context(CreateKubeClientSnafu)?;
-    let cluster_domain = retrieve_cluster_domain().context(ResolveKubernetesClusterDomainSnafu)?;
+    let cluster_info = KubernetesClusterInfo::new(cli_opts);
 
     Ok(Client::new(
         client,
         field_manager,
         default_namespace,
-        cluster_domain,
+        cluster_info,
     ))
 }
 
 #[cfg(test)]
 mod tests {
+    use std::{collections::BTreeMap, time::Duration};
+
+    use clap::Parser;
     use futures::StreamExt;
-    use k8s_openapi::api::core::v1::{Container, Pod, PodSpec};
-    use k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector;
-    use kube::api::{ObjectMeta, PostParams, ResourceExt};
-    use kube::runtime::watcher;
-    use kube::runtime::watcher::Event;
-    use std::collections::BTreeMap;
-    use std::time::Duration;
+    use k8s_openapi::{
+        api::core::v1::{Container, Pod, PodSpec},
+        apimachinery::pkg::apis::meta::v1::LabelSelector,
+    };
+    use kube::{
+        api::{ObjectMeta, PostParams, ResourceExt},
+        runtime::watcher::{self, Event},
+    };
     use tokio::time::error::Elapsed;
 
+    use crate::cli::ProductOperatorRun;
+
     #[tokio::test]
     #[ignore = "Tests depending on Kubernetes are not ran by default"]
     async fn k8s_test_wait_created() {
-        let client = super::initialize_operator(None)
+        let cli_opts = ProductOperatorRun::parse_from(["run"]);
+        let client = super::initialize_operator(&cli_opts, None)
             .await
             .expect("KUBECONFIG variable must be configured.");
 
@@ -740,7 +755,8 @@ mod tests {
     #[tokio::test]
     #[ignore = "Tests depending on Kubernetes are not ran by default"]
     async fn k8s_test_wait_created_timeout() {
-        let client = super::initialize_operator(None)
+        let cli_opts = ProductOperatorRun::parse_from(["run"]);
+        let client = super::initialize_operator(&cli_opts, None)
             .await
             .expect("KUBECONFIG variable must be configured.");
 
@@ -760,7 +776,8 @@ mod tests {
     #[tokio::test]
     #[ignore = "Tests depending on Kubernetes are not ran by default"]
     async fn k8s_test_list_with_label_selector() {
-        let client = super::initialize_operator(None)
+        let cli_opts = ProductOperatorRun::parse_from(["run"]);
+        let client = super::initialize_operator(&cli_opts, None)
             .await
             .expect("KUBECONFIG variable must be configured.");
 

crates/stackable-operator/src/utils/cluster_domain.rs

@@ -0,0 +1,34 @@
+use std::str::FromStr;
+
+use crate::{cli::ProductOperatorRun, commons::networking::DomainName};
+
+const KUBERNETES_CLUSTER_DOMAIN_DEFAULT: &str = "cluster.local";
+
+#[derive(Debug, Clone)]
+pub struct KubernetesClusterInfo {
+    pub cluster_domain: DomainName,
+}
+
+impl KubernetesClusterInfo {
+    pub fn new(cli_opts: &ProductOperatorRun) -> Self {
+        let cluster_domain = match &cli_opts.kubernetes_cluster_domain {
+            Some(cluster_domain) => {
+                tracing::info!(%cluster_domain, "Using configured Kubernetes cluster domain");
+
+                cluster_domain.clone()
+            }
+            None => {
+                // TODO(sbernauer): Do some sort of advanced auto-detection, see https://github.com/stackabletech/issues/issues/436.
+                // There have been attempts of parsing the `/etc/resolv.conf`, but they have been
+                // reverted. Please read on the linked Issue for details.
+                let cluster_domain = DomainName::from_str(KUBERNETES_CLUSTER_DOMAIN_DEFAULT)
+                    .expect("KUBERNETES_CLUSTER_DOMAIN_DEFAULT constant must a valid domain");
+                tracing::info!(%cluster_domain, "Defaulting Kubernetes cluster domain as it has not been configured");
+
+                cluster_domain
+            }
+        };
+
+        Self { cluster_domain }
+    }
+}

crates/stackable-operator/src/utils/cluster_info.rs

@@ -1,5 +1,5 @@
 pub mod bash;
-pub mod cluster_domain;
+pub mod cluster_info;
 pub mod crds;
 pub mod logging;
 mod option;