Added olm-deployer crate.

Author: razvan

Cargo.lock

@@ -1,5 +1,5 @@
 [workspace]
-members = ["rust/operator-binary", "rust/csi-grpc"]
+members = ["rust/operator-binary", "rust/csi-grpc", "rust/olm-deployer"]
 resolver = "2"
 
 [workspace.package]
@@ -21,6 +21,8 @@ pin-project = "1.1"
 prost = "0.13"
 prost-types = "0.13"
 serde = "1.0"
+serde_json = "1.0"
+serde_yaml = "0.9"
 snafu = "0.8"
 stackable-operator = { git = "https://github.com/stackabletech/operator-rs.git", tag = "stackable-operator-0.85.0" }
 strum = { version = "0.26", features = ["derive"] }
@@ -31,6 +33,7 @@ tonic = "0.12"
 tonic-build = "0.12"
 tonic-reflection = "0.12"
 tracing = "0.1.40"
+walkdir = "2.5.0"
 
 [patch."https://github.com/stackabletech/operator-rs.git"]
 # stackable-operator = { path = "../operator-rs/crates/stackable-operator" }

Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "olm-deployer"
+description = "OLM deployment helper."
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+publish = false
+
+[dependencies]
+anyhow.workspace = true
+clap.workspace = true
+tokio.workspace = true
+tracing.workspace = true
+stackable-operator.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+serde_yaml.workspace = true
+walkdir.workspace = true
+
+[build-dependencies]
+built.workspace = true

rust/olm-deployer/Cargo.toml

@@ -0,0 +1,3 @@
+fn main() {
+    built::write_built_file().unwrap();
+}

rust/olm-deployer/build.rs

@@ -0,0 +1,64 @@
+use stackable_operator::kube::{api::DynamicObject, ResourceExt};
+
+pub fn container<'a>(
+    target: &'a mut DynamicObject,
+    container_name: &str,
+) -> anyhow::Result<&'a mut serde_json::Value> {
+    let tname = target.name_any();
+    let path = "template/spec/containers".split("/");
+    match get_or_create(target.data.pointer_mut("/spec").unwrap(), path)? {
+        serde_json::Value::Array(containers) => {
+            for c in containers {
+                if c.is_object() {
+                    if let Some(serde_json::Value::String(name)) = c.get("name") {
+                        if container_name == name {
+                            return Ok(c);
+                        }
+                    }
+                } else {
+                    anyhow::bail!("container is not a object: {:?}", c);
+                }
+            }
+            anyhow::bail!("container named {container_name} not found");
+        }
+        _ => anyhow::bail!("no containers found in object {tname}"),
+    }
+}
+
+/// Returns the object nested in `root` by traversing the `path` of nested keys.
+/// Creates any missing objects in path.
+/// In case of success, the returned value is either the existing object or
+/// serde_json::Value::Null.
+/// Returns an error if any of the nested objects has a type other than map.
+pub fn get_or_create<'a, 'b, I>(
+    root: &'a mut serde_json::Value,
+    path: I,
+) -> anyhow::Result<&'a mut serde_json::Value>
+where
+    I: IntoIterator<Item = &'b str>,
+{
+    let mut iter = path.into_iter();
+    match iter.next() {
+        None => Ok(root),
+        Some(first) => {
+            let new_root = get_or_insert_default_object(root, first)?;
+            get_or_create(new_root, iter)
+        }
+    }
+}
+
+/// Given a map object create or return the object corresponding to the given `key`.
+fn get_or_insert_default_object<'a>(
+    value: &'a mut serde_json::Value,
+    key: &str,
+) -> anyhow::Result<&'a mut serde_json::Value> {
+    let map = match value {
+        serde_json::Value::Object(map) => map,
+        x @ serde_json::Value::Null => {
+            *x = serde_json::json!({});
+            x.as_object_mut().unwrap()
+        }
+        x => anyhow::bail!("invalid type {x:?}, expected map"),
+    };
+    Ok(map.entry(key).or_insert_with(|| serde_json::Value::Null))
+}

rust/olm-deployer/src/data.rs

@@ -0,0 +1,159 @@
+use stackable_operator::{
+    k8s_openapi::api::{apps::v1::Deployment, core::v1::EnvVar},
+    kube::{
+        api::{DynamicObject, GroupVersionKind},
+        ResourceExt,
+    },
+};
+
+use crate::data::container;
+
+/// Copy the environment from the "listener-operator-deployer" container in `source`
+/// to the container "listener-operator" in `target`.
+/// The `target` must be a DaemonSet object otherwise this is a no-op.
+pub(super) fn maybe_copy_env(
+    source: &Deployment,
+    target: &mut DynamicObject,
+    target_gvk: &GroupVersionKind,
+) -> anyhow::Result<()> {
+    if target_gvk.kind == "DaemonSet" {
+        if let Some(env) = deployer_env_var(source) {
+            match container(target, "listener-operator")? {
+                serde_json::Value::Object(c) => {
+                    let json_env = env
+                        .iter()
+                        .map(|e| serde_json::json!(e))
+                        .collect::<Vec<serde_json::Value>>();
+
+                    match c.get_mut("env") {
+                        Some(env) => match env {
+                            v @ serde_json::Value::Null => {
+                                *v = serde_json::json!(json_env);
+                            }
+                            serde_json::Value::Array(container_env) => {
+                                container_env.extend_from_slice(&json_env)
+                            }
+                            _ => anyhow::bail!("env is not null or an array"),
+                        },
+                        None => {
+                            c.insert("env".to_string(), serde_json::json!(json_env));
+                        }
+                    }
+                }
+                _ => anyhow::bail!("no containers found in object {}", target.name_any()),
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn deployer_env_var(deployment: &Deployment) -> Option<&Vec<EnvVar>> {
+    deployment
+        .spec
+        .as_ref()
+        .and_then(|ds| ds.template.spec.as_ref())
+        .map(|ts| ts.containers.iter())
+        .into_iter()
+        .flatten()
+        .filter(|c| c.name == "listener-operator-deployer")
+        .last()
+        .and_then(|c| c.env.as_ref())
+}
+
+#[cfg(test)]
+mod test {
+    use std::sync::LazyLock;
+
+    use anyhow::Result;
+    use serde::Deserialize;
+
+    use super::*;
+
+    static DAEMONSET: LazyLock<DynamicObject> = LazyLock::new(|| {
+        const STR_DAEMONSET: &str = r#"
+---
+apiVersion: apps/v1
+kind: DaemonSet
+metadata:
+  name: listener-operator-daemonset
+spec:
+  template:
+    spec:
+      containers:
+        - name: listener-operator
+          image: "quay.io/stackable/listener-operator@sha256:bb5063aa67336465fd3fa80a7c6fd82ac6e30ebe3ffc6dba6ca84c1f1af95bfe"
+          env:
+            - name: NAME1
+              value: value1
+"#;
+
+        let data =
+            serde_yaml::Value::deserialize(serde_yaml::Deserializer::from_str(STR_DAEMONSET))
+                .unwrap();
+        serde_yaml::from_value(data).unwrap()
+    });
+
+    static DEPLOYMENT: LazyLock<Deployment> = LazyLock::new(|| {
+        const STR_DEPLOYMENT: &str = r#"
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: listener-operator-deployer
+  uid: d9287d0a-3069-47c3-8c90-b714dc6d1af5
+spec:
+  template:
+    spec:
+      containers:
+        - name: listener-operator-deployer
+          image: "quay.io/stackable/tools@sha256:bb02df387d8f614089fe053373f766e21b7a9a1ad04cb3408059014cb0f1388e"
+          env:
+            - name: NAME2
+              value: value2
+      tolerations:
+        - key: keep-out
+          value: "yes"
+          operator: Equal
+          effect: NoSchedule
+    "#;
+
+        let data =
+            serde_yaml::Value::deserialize(serde_yaml::Deserializer::from_str(STR_DEPLOYMENT))
+                .unwrap();
+        serde_yaml::from_value(data).unwrap()
+    });
+
+    #[test]
+    fn test_copy_env_var() -> Result<()> {
+        let gvk: GroupVersionKind = GroupVersionKind {
+            kind: "DaemonSet".to_string(),
+            version: "v1".to_string(),
+            group: "apps".to_string(),
+        };
+
+        let mut daemonset = DAEMONSET.clone();
+
+        maybe_copy_env(&DEPLOYMENT, &mut daemonset, &gvk)?;
+
+        let expected = serde_json::json!(vec![
+            EnvVar {
+                name: "NAME1".to_string(),
+                value: Some("value1".to_string()),
+                ..EnvVar::default()
+            },
+            EnvVar {
+                name: "NAME2".to_string(),
+                value: Some("value2".to_string()),
+                ..EnvVar::default()
+            },
+        ]);
+        assert_eq!(
+            container(&mut daemonset, "listener-operator")?
+                .get("env")
+                .unwrap(),
+            &expected
+        );
+        Ok(())
+    }
+}