WIP

Author: sbernauer

crates/stackable-operator/src/builder/pod/container.rs

@@ -1,4 +1,4 @@
-use std::fmt;
+use std::{borrow::Borrow, fmt};
 
 use indexmap::IndexMap;
 use k8s_openapi::api::core::v1::{
@@ -175,8 +175,14 @@ impl ContainerBuilder {
         self
     }
 
-    pub fn add_env_vars(&mut self, env_vars: Vec<EnvVar>) -> &mut Self {
-        self.env.get_or_insert_with(Vec::new).extend(env_vars);
+    pub fn add_env_vars<I>(&mut self, env_vars: I) -> &mut Self
+    where
+        I: IntoIterator,
+        I::Item: std::borrow::Borrow<EnvVar>,
+    {
+        self.env
+            .get_or_insert_with(Vec::new)
+            .extend(env_vars.into_iter().map(|e| e.borrow().clone()));
         self
     }
 

crates/stackable-operator/src/builder/pod/env.rs

@@ -0,0 +1,20 @@
+use k8s_openapi::api::core::v1::{EnvVar, EnvVarSource, SecretKeySelector};
+
+pub fn env_var_from_secret(
+    env_var_name: impl Into<String>,
+    secret_name: impl Into<String>,
+    secret_key: impl Into<String>,
+) -> EnvVar {
+    EnvVar {
+        name: env_var_name.into(),
+        value_from: Some(EnvVarSource {
+            secret_key_ref: Some(SecretKeySelector {
+                name: secret_name.into(),
+                key: secret_key.into(),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+        ..Default::default()
+    }
+}

crates/stackable-operator/src/builder/pod/mod.rs

@@ -29,6 +29,7 @@ use crate::{
 };
 
 pub mod container;
+pub mod env;
 pub mod probe;
 pub mod resources;
 pub mod security;

crates/stackable-operator/src/crd/database/client/celery.rs

@@ -0,0 +1,57 @@
+use k8s_openapi::api::core::v1::EnvVar;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::builder::pod::{container::ContainerBuilder, env::env_var_from_secret};
+
+/// TODO docs
+pub trait CeleryDatabaseConnection {
+    /// TODO docs, e.g. on what are valid characters for unique_database_name
+    fn celery_connection_details(
+        &self,
+        unique_database_name: &str,
+    ) -> CeleryDatabaseConnectionDetails;
+}
+
+pub struct CeleryDatabaseConnectionDetails {
+    /// The connection URI, which can contain env variable templates, e.g.
+    /// `redis://:${METADATA_DATABASE_PASSWORD}@airflow-redis-master:6379/0`
+    /// or
+    /// `<generic URI from the user>`.
+    pub uri_template: String,
+
+    /// The [`EnvVar`]s the operator needs to mount into the created Pods.
+    pub env_vars: Vec<EnvVar>,
+}
+
+impl CeleryDatabaseConnectionDetails {
+    pub fn add_to_container(&self, cb: &mut ContainerBuilder) {
+        cb.add_env_vars(self.env_vars.iter());
+    }
+}
+
+/// TODO docs
+#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GenericCeleryDatabaseConnection {
+    /// The name of the Secret that contains an `uri` key with the complete SQLAlchemy URI.
+    pub uri_secret: String,
+}
+
+impl CeleryDatabaseConnection for GenericCeleryDatabaseConnection {
+    fn celery_connection_details(
+        &self,
+        unique_database_name: &str,
+    ) -> CeleryDatabaseConnectionDetails {
+        let uri_env_name = format!(
+            "{upper}_DATABASE_URI",
+            upper = unique_database_name.to_uppercase()
+        );
+        let uri_env_var = env_var_from_secret(&uri_env_name, &self.uri_secret, "uri");
+
+        CeleryDatabaseConnectionDetails {
+            uri_template: format!("${{{uri_env_name}}}"),
+            env_vars: vec![uri_env_var],
+        }
+    }
+}

crates/stackable-operator/src/crd/database/client/jdbc.rs

@@ -0,0 +1,70 @@
+use k8s_openapi::api::core::v1::EnvVar;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+use crate::{
+    builder::pod::container::ContainerBuilder, crd::database::helpers::username_and_password_envs,
+};
+
+/// TODO docs
+pub trait JDBCDatabaseConnection {
+    /// TODO docs
+    fn jdbc_connection_details(
+        &self,
+        unique_database_name: &str,
+    ) -> Result<JDBCDatabaseConnectionDetails, crate::crd::database::Error>;
+}
+
+pub struct JDBCDatabaseConnectionDetails {
+    /// The Java class name of the driver, e.g. `org.postgresql.Driver`
+    pub driver: String,
+
+    /// The connection URI (without user and  password), e.g.
+    /// `jdbc:postgresql://airflow-postgresql:5432/airflow`
+    pub connection_uri: Url,
+
+    /// The [`EnvVar`] that mounts the credentials Secret and provides the username.
+    pub username_env: Option<EnvVar>,
+
+    /// The [`EnvVar`] that mounts the credentials Secret and provides the password.
+    pub password_env: Option<EnvVar>,
+}
+
+impl JDBCDatabaseConnectionDetails {
+    pub fn add_to_container(&self, cb: &mut ContainerBuilder) {
+        let env_vars = self.username_env.iter().chain(self.password_env.iter());
+        cb.add_env_vars(env_vars);
+    }
+}
+
+/// TODO docs
+#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GenericJDBCDatabaseConnection {
+    /// TODO docs
+    pub driver: String,
+
+    /// TODO docs
+    pub uri: Url,
+
+    /// TODO docs
+    pub credentials_secret: String,
+}
+
+impl JDBCDatabaseConnection for GenericJDBCDatabaseConnection {
+    fn jdbc_connection_details(
+        &self,
+        unique_database_name: &str,
+    ) -> Result<JDBCDatabaseConnectionDetails, crate::crd::database::Error> {
+        let (username_env, password_env) =
+            username_and_password_envs(unique_database_name, &self.credentials_secret);
+
+        Ok(JDBCDatabaseConnectionDetails {
+            driver: self.driver.clone(),
+            connection_uri: self.uri.clone(),
+            username_env: Some(username_env),
+            password_env: Some(password_env),
+        })
+    }
+}

crates/stackable-operator/src/crd/database/client/mod.rs

@@ -0,0 +1,3 @@
+pub mod celery;
+pub mod jdbc;
+pub mod sqlalchemy;

crates/stackable-operator/src/crd/database/client/sqlalchemy.rs

@@ -0,0 +1,57 @@
+use k8s_openapi::api::core::v1::EnvVar;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::builder::pod::{container::ContainerBuilder, env::env_var_from_secret};
+
+/// TODO docs
+pub trait SQLAlchemyDatabaseConnection {
+    /// TODO docs, e.g. on what are valid characters for unique_database_name
+    fn sqlalchemy_connection_details(
+        &self,
+        unique_database_name: &str,
+    ) -> SQLAlchemyDatabaseConnectionDetails;
+}
+
+pub struct SQLAlchemyDatabaseConnectionDetails {
+    /// The connection URI, which can contain env variable templates, e.g.
+    /// `postgresql+psycopg2://${METADATA_DATABASE_USERNAME}:${METADATA_DATABASE_PASSWORD}@airflow-postgresql:5432/airflow`
+    /// or
+    /// `<generic URI from the user>`.
+    pub uri_template: String,
+
+    /// The [`EnvVar`]s the operator needs to mount into the created Pods.
+    pub env_vars: Vec<EnvVar>,
+}
+
+impl SQLAlchemyDatabaseConnectionDetails {
+    pub fn add_to_container(&self, cb: &mut ContainerBuilder) {
+        cb.add_env_vars(self.env_vars.iter());
+    }
+}
+
+/// TODO docs
+#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GenericSQLAlchemyDatabaseConnection {
+    /// The name of the Secret that contains an `uri` key with the complete SQLAlchemy URI.
+    pub uri_secret: String,
+}
+
+impl SQLAlchemyDatabaseConnection for GenericSQLAlchemyDatabaseConnection {
+    fn sqlalchemy_connection_details(
+        &self,
+        unique_database_name: &str,
+    ) -> SQLAlchemyDatabaseConnectionDetails {
+        let uri_env_name = format!(
+            "{upper}_DATABASE_URI",
+            upper = unique_database_name.to_uppercase()
+        );
+        let uri_env_var = env_var_from_secret(&uri_env_name, &self.uri_secret, "uri");
+
+        SQLAlchemyDatabaseConnectionDetails {
+            uri_template: format!("${{{uri_env_name}}}"),
+            env_vars: vec![uri_env_var],
+        }
+    }
+}

crates/stackable-operator/src/crd/database/helpers.rs

@@ -0,0 +1,50 @@
+use std::collections::BTreeMap;
+
+use k8s_openapi::api::core::v1::EnvVar;
+
+use crate::builder::pod::env::env_var_from_secret;
+
+/// Returns the needed [`EnvVar`] mounts for username and password.
+///
+/// They will mount the specified Secret as env var into the Pod.
+pub fn username_and_password_envs(
+    unique_database_name: &str,
+    credentials_secret_name: &str,
+) -> (EnvVar, EnvVar) {
+    let (username_env_name, password_env_name) =
+        username_and_password_env_names(unique_database_name);
+    (
+        env_var_from_secret(username_env_name, credentials_secret_name, "username"),
+        env_var_from_secret(password_env_name, credentials_secret_name, "password"),
+    )
+}
+
+pub fn username_and_password_env_names(unique_database_name: &str) -> (String, String) {
+    let env_name_prefix = format!(
+        "{upper}_DATABASE",
+        upper = unique_database_name.to_uppercase()
+    );
+    (
+        format!("{env_name_prefix}_USERNAME"),
+        format!("{env_name_prefix}_PASSWORD"),
+    )
+}
+
+/// Returns
+///
+/// * If no params are defined: ""
+/// * If params are defined: "?key=value&foo=bar"
+pub fn connection_parameters_as_url_query_parameters(
+    parameters: &BTreeMap<String, String>,
+) -> String {
+    if parameters.is_empty() {
+        String::new()
+    } else {
+        let parameters = parameters
+            .iter()
+            .map(|(k, v)| format!("{k}={v}"))
+            .collect::<Vec<_>>()
+            .join("&");
+        format!("?{parameters}")
+    }
+}

crates/stackable-operator/src/crd/database/mod.rs

@@ -0,0 +1,40 @@
+use snafu::Snafu;
+
+pub mod client;
+mod helpers;
+pub mod server;
+#[cfg(test)]
+mod tests;
+
+#[derive(Debug, Snafu)]
+pub enum Error {
+    #[snafu(context(false), display("postgres error"))]
+    Postgres { source: server::postgres::Error },
+
+    #[snafu(context(false), display("derby error"))]
+    Derby { source: server::derby::Error },
+}
+
+// /// TODO docs
+// pub trait CeleryDatabaseConnection {
+//     /// TODO docs, e.g. on what are valid characters for unique_database_name
+//     fn celery_connection_details(
+//         &self,
+//         unique_database_name: &str,
+//     ) -> CeleryDatabaseConnectionDetails;
+// }
+
+// pub struct CeleryDatabaseConnectionDetails {
+//     /// The connection URI, which can contain env variable templates, e.g.
+//     /// `redis://:redis@airflow-redis-master:6379/0`
+//     pub uri_template: String,
+
+//     /// The [`EnvVar`]s the operator needs to mount into the created Pods.
+//     pub env_vars: Vec<EnvVar>,
+// }
+
+// impl CeleryDatabaseConnectionDetails {
+//     pub fn add_to_container(&self, cb: &mut ContainerBuilder) {
+//         cb.add_env_vars(self.env_vars.clone());
+//     }
+// }

crates/stackable-operator/src/crd/database/server/derby.rs

@@ -0,0 +1,40 @@
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use snafu::{ResultExt, Snafu};
+
+use crate::crd::database::client::jdbc::{JDBCDatabaseConnection, JDBCDatabaseConnectionDetails};
+
+#[derive(Debug, Snafu)]
+pub enum Error {
+    #[snafu(display("failed to parse connection URL"))]
+    ParseConnectionUrl { source: url::ParseError },
+}
+
+/// TODO docs
+#[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DerbyConnection {
+    /// TODO docs, especially on default
+    pub location: Option<String>,
+}
+
+impl JDBCDatabaseConnection for DerbyConnection {
+    fn jdbc_connection_details(
+        &self,
+        unique_database_name: &str,
+    ) -> Result<JDBCDatabaseConnectionDetails, crate::crd::database::Error> {
+        let location = self
+            .location
+            .clone()
+            .unwrap_or_else(|| format!("/tmp/derby/{unique_database_name}/derby.db"));
+        let connection_uri = format!("jdbc:derby:{location}",);
+        let connection_uri = connection_uri.parse().context(ParseConnectionUrlSnafu)?;
+
+        Ok(JDBCDatabaseConnectionDetails {
+            driver: "org.apache.derby.jdbc.ClientDriver".to_owned(),
+            connection_uri,
+            username_env: None,
+            password_env: None,
+        })
+    }
+}