chore: Add initial utxo address configuration

src/controller.rs

@@ -1,5 +1,9 @@
 use anyhow::bail;
-use k8s_openapi::api::{apps::v1::Deployment, core::v1::Service, networking::v1::Ingress};
+use k8s_openapi::api::{
+    apps::v1::Deployment,
+    core::v1::{ConfigMap, Service},
+    networking::v1::Ingress,
+};
 use kube::{
     api::{DeleteParams, ListParams, Patch, PatchParams},
     runtime::controller::Action,
@@ -43,6 +47,7 @@ impl From<HydraDoomNodeState> for String {
 
 pub struct K8sConstants {
     pub config_dir: String,
+    pub initial_utxo_config_dir: String,
     pub data_dir: String,
     pub persistence_dir: String,
     pub node_port: i32,
@@ -58,6 +63,7 @@ impl Default for K8sConstants {
     fn default() -> Self {
         Self {
             config_dir: "/etc/config".to_string(),
+            initial_utxo_config_dir: "/etc/initial_utxo_config".to_string(),
             data_dir: "/var/data".to_string(),
             persistence_dir: "/var/persistence".to_string(),
             node_port: 5001,
@@ -117,31 +123,11 @@ impl K8sContext {
             self.patch_deployment(crd),
             self.patch_service(crd),
             self.patch_ingress(crd),
+            self.patch_configmap(crd),
             self.patch_crd(crd)
         ) {
-            (Ok(_), Ok(_), Ok(_), Ok(_)) => (),
-            (Err(_), Ok(_), Ok(_), Ok(_)) => {
-                self.remove_service(crd).await?;
-                self.remove_ingress(crd).await?;
-            }
-            (Ok(_), Err(_), Ok(_), Ok(_)) => {
-                self.remove_deployment(crd).await?;
-                self.remove_ingress(crd).await?;
-            }
-            (Ok(_), Ok(_), Err(_), Ok(_)) => {
-                self.remove_deployment(crd).await?;
-                self.remove_service(crd).await?;
-            }
-            (Err(_), Err(_), Ok(_), Ok(_)) => {
-                self.remove_ingress(crd).await?;
-            }
-            (Err(_), Ok(_), Err(_), Ok(_)) => {
-                self.remove_service(crd).await?;
-            }
-            (Ok(_), Err(_), Err(_), Ok(_)) => {
-                self.remove_deployment(crd).await?;
-            }
-            _ => bail!("Failed to create resources"),
+            (Ok(_), Ok(_), Ok(_), Ok(_), Ok(_)) => (),
+            _ => bail!("Failed to apply patch for components."),
         };
 
         Ok(())
@@ -151,9 +137,10 @@ impl K8sContext {
         match tokio::join!(
             self.remove_deployment(crd),
             self.remove_service(crd),
-            self.remove_ingress(crd)
+            self.remove_ingress(crd),
+            self.remove_configmap(crd)
         ) {
-            (Ok(_), Ok(_), Ok(_)) => Ok(()),
+            (Ok(_), Ok(_), Ok(_), Ok(_)) => Ok(()),
             _ => bail!("Failed to remove resources"),
         }
     }
@@ -178,6 +165,33 @@ impl K8sContext {
         })
     }
 
+    async fn patch_configmap(&self, crd: &HydraDoomNode) -> anyhow::Result<ConfigMap> {
+        let api: Api<ConfigMap> = Api::namespaced(self.client.clone(), &crd.namespace().unwrap());
+
+        // Create or patch the configmap
+        api.patch(
+            &crd.internal_name(),
+            &PatchParams::apply("hydra-doom-pod-controller"),
+            &Patch::Apply(&crd.configmap(&self.config, &self.constants)),
+        )
+        .await
+        .map_err(|err| {
+            error!(err = err.to_string(), "Failed to create configmap.");
+            err.into()
+        })
+    }
+
+    async fn remove_configmap(&self, crd: &HydraDoomNode) -> anyhow::Result<()> {
+        let api: Api<ConfigMap> = Api::namespaced(self.client.clone(), &crd.namespace().unwrap());
+        match api
+            .delete(&crd.internal_name(), &DeleteParams::default())
+            .await
+        {
+            Ok(_) => Ok(()),
+            Err(e) => Err(e.into()),
+        }
+    }
+
     async fn patch_deployment(&self, crd: &HydraDoomNode) -> anyhow::Result<Deployment> {
         let deployments: Api<Deployment> =
             Api::namespaced(self.client.clone(), &crd.namespace().unwrap());

src/custom_resource.rs

@@ -1,7 +1,7 @@
 use k8s_openapi::api::{
     apps::v1::{Deployment, DeploymentSpec},
     core::v1::{
-        ConfigMapVolumeSource, Container, ContainerPort, EmptyDirVolumeSource, PodSpec,
+        ConfigMap, ConfigMapVolumeSource, Container, ContainerPort, EmptyDirVolumeSource, PodSpec,
         PodTemplateSpec, Service, ServicePort, ServiceSpec, Volume, VolumeMount,
     },
     networking::v1::{
@@ -40,6 +40,8 @@ pub static HYDRA_DOOM_NODE_FINALIZER: &str = "hydradoomnode/finalizer";
 #[serde(rename_all = "camelCase")]
 pub struct HydraDoomNodeSpec {
     pub image: Option<String>,
+    pub offline: Option<bool>,
+    pub initial_utxo_address: Option<String>,
     pub open_head_image: Option<String>,
     pub sidecar_image: Option<String>,
     pub configmap: Option<String>,
@@ -99,6 +101,35 @@ impl HydraDoomNode {
         format!("{}.{}", self.name_any(), config.external_domain,)
     }
 
+    pub fn configmap(&self, _config: &Config, _constants: &K8sConstants) -> ConfigMap {
+        let name = self.internal_name();
+
+        ConfigMap {
+            metadata: ObjectMeta {
+                name: Some(name),
+                ..Default::default()
+            },
+            data: Some(BTreeMap::from([(
+                "utxo.json".to_string(),
+                format!(
+                    r#"{{
+                    "0000000000000000000000000000000000000000000000000000000000000000#0": {{
+                        "address": "{}",
+                        "value": {{
+                            "lovelace": 1000000000
+                        }}
+                    }}
+                }}"#,
+                    self.spec.initial_utxo_address.clone().unwrap_or(
+                        "addr_test1vphyqcvtwdpuwlmslna29ymaua8e9cswlmllt9wkey345cqgtzv2j"
+                            .to_string()
+                    )
+                ),
+            )])),
+            ..Default::default()
+        }
+    }
+
     pub fn deployment(&self, config: &Config, constants: &K8sConstants) -> Deployment {
         let name = self.internal_name();
         let labels = self.internal_labels();
@@ -175,7 +206,7 @@ impl HydraDoomNode {
                                     "--ledger-protocol-parameters".to_string(),
                                     format!("{}/protocol-parameters.json", constants.config_dir),
                                     "--initial-utxo".to_string(),
-                                    format!("{}/utxo.json", constants.config_dir),
+                                    format!("{}/utxo.json", constants.initial_utxo_config_dir),
                                     "--persistence-dir".to_string(),
                                     format!("{}/hydra-state", constants.persistence_dir),
                                 ]),
@@ -186,6 +217,11 @@ impl HydraDoomNode {
                                     ..Default::default()
                                 }]),
                                 volume_mounts: Some(vec![
+                                    VolumeMount {
+                                        name: "initial_utxo".to_string(),
+                                        mount_path: constants.initial_utxo_config_dir.clone(),
+                                        ..Default::default()
+                                    },
                                     VolumeMount {
                                         name: "config".to_string(),
                                         mount_path: constants.config_dir.clone(),
@@ -254,6 +290,14 @@ impl HydraDoomNode {
                                 }),
                                 ..Default::default()
                             },
+                            Volume {
+                                name: "initial_utxo".to_string(),
+                                config_map: Some(ConfigMapVolumeSource {
+                                    name: constants.initial_utxo_config_dir.clone(),
+                                    ..Default::default()
+                                }),
+                                ..Default::default()
+                            },
                         ]),
                         ..Default::default()
                     }),