WIP

Author: sbernauer

Cargo.lock

@@ -1,6 +1,6 @@
 use stackable_operator::time::Duration;
 
-/// The default CA validity time span of one hour (3600 seconds).
+/// The default CA validity time span
 pub const DEFAULT_CA_VALIDITY: Duration = Duration::from_hours_unchecked(1);
 
 /// The root CA subject name containing only the common name.

crates/stackable-certs/src/ca/consts.rs

@@ -22,6 +22,7 @@
 use std::ops::Deref;
 
 use snafu::Snafu;
+use stackable_operator::time::Duration;
 use x509_cert::{Certificate, spki::EncodePublicKey};
 #[cfg(feature = "rustls")]
 use {
@@ -36,6 +37,9 @@ use crate::keys::CertificateKeypair;
 pub mod ca;
 pub mod keys;
 
+/// The default certificate validity time span
+pub const DEFAULT_CERTIFICATE_VALIDITY: Duration = Duration::from_hours_unchecked(1);
+
 /// Error variants which can be encountered when creating a new
 /// [`CertificatePair`].
 #[derive(Debug, Snafu)]

crates/stackable-certs/src/lib.rs

@@ -163,7 +163,7 @@ pub enum Command<Run: Args = ProductOperatorRun> {
 /// Can be embedded into an extended argument set:
 ///
 /// ```rust
-/// # use stackable_operator::cli::{Command, ProductOperatorRun, ProductConfigPath};
+/// # use stackable_operator::cli::{Command, OperatorEnvironmentOpts, ProductOperatorRun, ProductConfigPath};
 /// use clap::Parser;
 /// use stackable_operator::namespace::WatchNamespace;
 /// use stackable_telemetry::tracing::TelemetryOptions;
@@ -176,14 +176,31 @@ pub enum Command<Run: Args = ProductOperatorRun> {
 ///     common: ProductOperatorRun,
 /// }
 ///
-/// let opts = Command::<Run>::parse_from(["foobar-operator", "run", "--name", "foo", "--product-config", "bar", "--watch-namespace", "foobar"]);
+/// let opts = Command::<Run>::parse_from([
+///     "foobar-operator",
+///     "run",
+///     "--name",
+///     "foo",
+///     "--product-config",
+///     "bar",
+///     "--watch-namespace",
+///     "foobar",
+///     "--operator-namespace",
+///     "stackable-operators",
+///     "--operator-service-name",
+///     "foo-operator",
+/// ]);
 /// assert_eq!(opts, Command::Run(Run {
 ///     name: "foo".to_string(),
 ///     common: ProductOperatorRun {
 ///         product_config: ProductConfigPath::from("bar".as_ref()),
 ///         watch_namespace: WatchNamespace::One("foobar".to_string()),
 ///         telemetry_arguments: TelemetryOptions::default(),
 ///         cluster_info_opts: Default::default(),
+///         operator_environment: OperatorEnvironmentOpts {
+///             operator_namespace: "stackable-operators".to_string(),
+///             operator_service_name: "foo-operator".to_string(),
+///         },
 ///     },
 /// }));
 /// ```
@@ -216,6 +233,9 @@ pub struct ProductOperatorRun {
     #[arg(long, env, default_value = "")]
     pub watch_namespace: WatchNamespace,
 
+    #[command(flatten)]
+    pub operator_environment: OperatorEnvironmentOpts,
+
     #[command(flatten)]
     pub telemetry_arguments: TelemetryOptions,
 
@@ -278,6 +298,18 @@ impl ProductConfigPath {
     }
 }
 
+#[derive(clap::Parser, Debug, PartialEq, Eq)]
+pub struct OperatorEnvironmentOpts {
+    /// The namespace the operator is running in, usually `stackable-operators`.
+    #[arg(long, env)]
+    pub operator_namespace: String,
+
+    /// The name of the service the operator is reachable at, usually
+    /// something like `<product>-operator`.
+    #[arg(long, env)]
+    pub operator_service_name: String,
+}
+
 #[cfg(test)]
 mod tests {
     use std::{env, fs::File};
@@ -292,6 +324,8 @@ mod tests {
     const DEPLOY_FILE_PATH: &str = "deploy_config_spec_properties.yaml";
     const DEFAULT_FILE_PATH: &str = "default_file_path_properties.yaml";
     const WATCH_NAMESPACE: &str = "WATCH_NAMESPACE";
+    const OPERATOR_NAMESPACE: &str = "OPERATOR_NAMESPACE";
+    const OPERATOR_SERVICE_NAME: &str = "OPERATOR_SERVICE_NAME";
 
     #[test]
     fn verify_cli() {
@@ -388,6 +422,10 @@ mod tests {
             "bar",
             "--watch-namespace",
             "foo",
+            "--operator-namespace",
+            "stackable-operators",
+            "--operator-service-name",
+            "foo-operator",
         ]);
         assert_eq!(
             opts,
@@ -396,23 +434,42 @@ mod tests {
                 watch_namespace: WatchNamespace::One("foo".to_string()),
                 cluster_info_opts: Default::default(),
                 telemetry_arguments: Default::default(),
+                operator_environment: OperatorEnvironmentOpts {
+                    operator_namespace: "stackable-operators".to_string(),
+                    operator_service_name: "foo-operator".to_string(),
+                }
             }
         );
 
         // no cli / no env
-        let opts = ProductOperatorRun::parse_from(["run", "--product-config", "bar"]);
+        let opts = ProductOperatorRun::parse_from([
+            "run",
+            "--product-config",
+            "bar",
+            "--operator-namespace",
+            "stackable-operators",
+            "--operator-service-name",
+            "foo-operator",
+        ]);
         assert_eq!(
             opts,
             ProductOperatorRun {
                 product_config: ProductConfigPath::from("bar".as_ref()),
                 watch_namespace: WatchNamespace::All,
                 cluster_info_opts: Default::default(),
                 telemetry_arguments: Default::default(),
+                operator_environment: OperatorEnvironmentOpts {
+                    operator_namespace: "stackable-operators".to_string(),
+                    operator_service_name: "foo-operator".to_string(),
+                }
             }
         );
 
         // env with namespace
         unsafe { env::set_var(WATCH_NAMESPACE, "foo") };
+        unsafe { env::set_var(OPERATOR_SERVICE_NAME, "foo-operator") };
+        unsafe { env::set_var(OPERATOR_NAMESPACE, "stackable-operators") };
+
         let opts = ProductOperatorRun::parse_from(["run", "--product-config", "bar"]);
         assert_eq!(
             opts,
@@ -421,6 +478,10 @@ mod tests {
                 watch_namespace: WatchNamespace::One("foo".to_string()),
                 cluster_info_opts: Default::default(),
                 telemetry_arguments: Default::default(),
+                operator_environment: OperatorEnvironmentOpts {
+                    operator_namespace: "stackable-operators".to_string(),
+                    operator_service_name: "foo-operator".to_string(),
+                }
             }
         );
     }

crates/stackable-operator/src/cli.rs

@@ -73,22 +73,6 @@ const OTEL_TRACE_ID_TO: &str = "opentelemetry.trace_id.to";
 /// # let _: Router = router;
 /// ```
 ///
-/// ### Example with Webhook
-///
-/// The usage is even simpler when combined with the `stackable_webhook` crate.
-/// The webhook server has built-in support to automatically emit HTTP spans on
-/// every incoming request.
-///
-/// ```
-/// use stackable_webhook::{WebhookServer, Options};
-/// use axum::Router;
-///
-/// let router = Router::new();
-/// let server = WebhookServer::new(router, Options::default());
-///
-/// # let _: WebhookServer = server;
-/// ```
-///
 /// This layer is implemented based on [this][1] official Tower guide.
 ///
 /// [1]: https://github.com/tower-rs/tower/blob/master/guides/building-a-middleware-from-scratch.md

crates/stackable-telemetry/src/instrumentation/axum/mod.rs

@@ -26,3 +26,4 @@ tower-http.workspace = true
 tower.workspace = true
 tracing.workspace = true
 tracing-opentelemetry.workspace = true
+x509-cert.workspace = true