fix: Rename CRD

bootstrap/stage1/crd.tf

@@ -1,22 +1,22 @@
-resource "kubernetes_manifest" "customresourcedefinition_hydradoompods_hydra_doom" {
+resource "kubernetes_manifest" "customresourcedefinition_hydradoomnodes_hydra_doom" {
   manifest = {
     "apiVersion" = "apiextensions.k8s.io/v1"
     "kind" = "CustomResourceDefinition"
     "metadata" = {
-      "name" = "hydradoompods.hydra.doom"
+      "name" = "hydradoomnodes.hydra.doom"
     }
     "spec" = {
       "group" = "hydra.doom"
       "names" = {
         "categories" = [
           "hydradoom",
         ]
-        "kind" = "HydraDoomPod"
-        "plural" = "hydradoompods"
+        "kind" = "HydraDoomNode"
+        "plural" = "hydradoomnodes"
         "shortNames" = [
-          "hydradoompod",
+          "hydradoomnode",
         ]
-        "singular" = "hydradoompod"
+        "singular" = "hydradoomnode"
       }
       "scope" = "Namespaced"
       "versions" = [
@@ -36,7 +36,7 @@ resource "kubernetes_manifest" "customresourcedefinition_hydradoompods_hydra_doo
           "name" = "v1alpha1"
           "schema" = {
             "openAPIV3Schema" = {
-              "description" = "Auto-generated derived type for HydraDoomPodSpec via `CustomResource`"
+              "description" = "Auto-generated derived type for HydraDoomNodeSpec via `CustomResource`"
               "properties" = {
                 "spec" = {
                   "properties" = {
@@ -106,7 +106,7 @@ resource "kubernetes_manifest" "customresourcedefinition_hydradoompods_hydra_doo
               "required" = [
                 "spec",
               ]
-              "title" = "HydraDoomPod"
+              "title" = "HydraDoomNode"
               "type" = "object"
             }
           }

bootstrap/stage2/config.tf

@@ -5,6 +5,8 @@ resource "kubernetes_config_map" "node-config" {
   }
 
   data = {
-    "admin.sk" = "${file("${path.module}/admin.sk")}"
+    "admin.sk"                 = "${file("${path.module}/admin.sk")}"
+    "protocol-parameters.json" = "${file("${path.module}/protocol-parameters.json")}"
+    "utxo.json"                = "${file("${path.module}/utxo.json")}"
   }
 }

src/bin/crdgen.rs

@@ -1,6 +1,6 @@
-use doom_patrol::custom_resource::HydraDoomPod;
+use doom_patrol::custom_resource::HydraDoomNode;
 use kube::CustomResourceExt;
 
 fn main() {
-    print!("{}", serde_yaml::to_string(&HydraDoomPod::crd()).unwrap())
+    print!("{}", serde_yaml::to_string(&HydraDoomNode::crd()).unwrap())
 }

src/bin/operator.rs

@@ -7,7 +7,7 @@ use tracing::{error, info, instrument};
 use doom_patrol::{
     config::Config,
     controller::{error_policy, reconcile, K8sContext},
-    custom_resource::HydraDoomPod,
+    custom_resource::HydraDoomNode,
 };
 
 #[tokio::main]
@@ -23,7 +23,7 @@ async fn main() -> Result<()> {
     let context = Arc::new(K8sContext::new(client.clone(), config));
 
     // Create controller for MyApp custom resource
-    let api: Api<HydraDoomPod> = Api::all(client);
+    let api: Api<HydraDoomNode> = Api::all(client);
     info!("Running controller.");
     Controller::new(api, Default::default())
         .run(reconcile, error_policy, context)

src/controller.rs

@@ -10,9 +10,9 @@ use std::{sync::Arc, time::Duration};
 use thiserror::Error;
 use tracing::{error, info};
 
-use crate::{config::Config, custom_resource::HydraDoomPodStatus};
+use crate::{config::Config, custom_resource::HydraDoomNodeStatus};
 
-use super::custom_resource::{HydraDoomPod, HYDRA_DOOM_POD_FINALIZER};
+use super::custom_resource::{HydraDoomNode, HYDRA_DOOM_NODE_FINALIZER};
 
 pub struct K8sConstants {
     pub config_dir: String,
@@ -48,7 +48,7 @@ impl K8sContext {
         }
     }
 
-    pub async fn patch(&self, crd: &HydraDoomPod) -> anyhow::Result<()> {
+    pub async fn patch(&self, crd: &HydraDoomNode) -> anyhow::Result<()> {
         info!("Running patch");
         match tokio::join!(
             self.patch_deployment(crd),
@@ -80,7 +80,7 @@ impl K8sContext {
         Ok(())
     }
 
-    pub async fn delete(&self, crd: &HydraDoomPod) -> anyhow::Result<()> {
+    pub async fn delete(&self, crd: &HydraDoomNode) -> anyhow::Result<()> {
         match tokio::join!(self.remove_deployment(crd), self.remove_service(crd)) {
             (Ok(_), Ok(_)) => Ok(()),
             (Ok(_), Err(err)) => Err(err.context("Failed to remove service.")),
@@ -89,12 +89,12 @@ impl K8sContext {
         }
     }
 
-    async fn patch_crd(&self, crd: &HydraDoomPod) -> anyhow::Result<HydraDoomPod> {
-        let api: Api<HydraDoomPod> =
+    async fn patch_crd(&self, crd: &HydraDoomNode) -> anyhow::Result<HydraDoomNode> {
+        let api: Api<HydraDoomNode> =
             Api::namespaced(self.client.clone(), &crd.namespace().unwrap());
 
         // Create or patch the deployment
-        let status = serde_json::to_value(HydraDoomPodStatus {
+        let status = serde_json::to_value(HydraDoomNodeStatus {
             local_url: format!(
                 "ws://{}.{}.svc.cluster.local:{}",
                 crd.name_any(),
@@ -115,7 +115,7 @@ impl K8sContext {
             &Patch::Merge(json!({
                 "status": status,
                 "metadata": {
-                    "finalizers": [HYDRA_DOOM_POD_FINALIZER]
+                    "finalizers": [HYDRA_DOOM_NODE_FINALIZER]
                 }
             })),
         )
@@ -137,14 +137,14 @@ impl K8sContext {
         })
     }
 
-    async fn patch_deployment(&self, crd: &HydraDoomPod) -> anyhow::Result<Deployment> {
+    async fn patch_deployment(&self, crd: &HydraDoomNode) -> anyhow::Result<Deployment> {
         let deployments: Api<Deployment> =
             Api::namespaced(self.client.clone(), &crd.namespace().unwrap());
 
         // Create or patch the deployment
         deployments
             .patch(
-                &crd.pod_name(),
+                &crd.internal_name(),
                 &PatchParams::apply("hydra-doom-pod-controller"),
                 &Patch::Apply(&crd.deployment(&self.config, &self.constants)),
             )
@@ -155,24 +155,24 @@ impl K8sContext {
             })
     }
 
-    async fn remove_deployment(&self, crd: &HydraDoomPod) -> anyhow::Result<()> {
+    async fn remove_deployment(&self, crd: &HydraDoomNode) -> anyhow::Result<()> {
         let deployments: Api<Deployment> =
             Api::namespaced(self.client.clone(), &crd.namespace().unwrap());
         let dp = DeleteParams::default();
 
-        match deployments.delete(&crd.pod_name(), &dp).await {
+        match deployments.delete(&crd.internal_name(), &dp).await {
             Ok(_) => Ok(()),
             Err(e) => Err(e.into()),
         }
     }
 
-    async fn patch_service(&self, crd: &HydraDoomPod) -> anyhow::Result<Service> {
+    async fn patch_service(&self, crd: &HydraDoomNode) -> anyhow::Result<Service> {
         // Apply the service to the cluster
         let services: Api<Service> =
             Api::namespaced(self.client.clone(), &crd.namespace().unwrap());
         services
             .patch(
-                &crd.pod_name(),
+                &crd.internal_name(),
                 &PatchParams::apply("hydra-doom-pod-controller"),
                 &Patch::Apply(&crd.service(&self.config, &self.constants)),
             )
@@ -183,11 +183,11 @@ impl K8sContext {
             })
     }
 
-    async fn remove_service(&self, crd: &HydraDoomPod) -> anyhow::Result<()> {
+    async fn remove_service(&self, crd: &HydraDoomNode) -> anyhow::Result<()> {
         let services: Api<Service> =
             Api::namespaced(self.client.clone(), &crd.namespace().unwrap());
         let dp = DeleteParams::default();
-        match services.delete(&crd.pod_name(), &dp).await {
+        match services.delete(&crd.internal_name(), &dp).await {
             Ok(_) => Ok(()),
             Err(e) => Err(e.into()),
         }
@@ -208,23 +208,23 @@ impl From<anyhow::Error> for Error {
 }
 type Result<T, E = Error> = std::result::Result<T, E>;
 
-pub async fn reconcile(crd: Arc<HydraDoomPod>, ctx: Arc<K8sContext>) -> Result<Action, Error> {
+pub async fn reconcile(crd: Arc<HydraDoomNode>, ctx: Arc<K8sContext>) -> Result<Action, Error> {
     tracing::info!("Reconciling {}", crd.name_any());
     // Check if deletion timestamp is set
     if crd.metadata.deletion_timestamp.is_some() {
-        let hydra_doom_pod_api: Api<HydraDoomPod> =
+        let hydra_doom_pod_api: Api<HydraDoomNode> =
             Api::namespaced(ctx.client.clone(), &crd.namespace().unwrap());
         // Finalizer logic for cleanup
         if crd
             .finalizers()
-            .contains(&HYDRA_DOOM_POD_FINALIZER.to_string())
+            .contains(&HYDRA_DOOM_NODE_FINALIZER.to_string())
         {
             // Delete associated resources
             ctx.delete(&crd).await?;
             // Remove finalizer
             let patch = json!({
                 "metadata": {
-                    "finalizers": crd.finalizers().iter().filter(|f| *f != HYDRA_DOOM_POD_FINALIZER).collect::<Vec<_>>()
+                    "finalizers": crd.finalizers().iter().filter(|f| *f != HYDRA_DOOM_NODE_FINALIZER).collect::<Vec<_>>()
                 }
             });
             let _ = hydra_doom_pod_api
@@ -244,7 +244,7 @@ pub async fn reconcile(crd: Arc<HydraDoomPod>, ctx: Arc<K8sContext>) -> Result<A
     Ok(Action::await_change())
 }
 
-pub fn error_policy(crd: Arc<HydraDoomPod>, err: &Error, _ctx: Arc<K8sContext>) -> Action {
+pub fn error_policy(crd: Arc<HydraDoomNode>, err: &Error, _ctx: Arc<K8sContext>) -> Action {
     error!(
         error = err.to_string(),
         crd = serde_json::to_string(&crd).unwrap(),

src/custom_resource.rs

@@ -14,25 +14,25 @@ use crate::config::Config;
 
 use super::controller::K8sConstants;
 
-pub static HYDRA_DOOM_POD_FINALIZER: &str = "hydradoompod/finalizer";
+pub static HYDRA_DOOM_NODE_FINALIZER: &str = "hydradoomnode/finalizer";
 
 #[derive(CustomResource, Deserialize, Serialize, Clone, Debug, JsonSchema)]
 #[kube(
-    kind = "HydraDoomPod",
+    kind = "HydraDoomNode",
     group = "hydra.doom",
     version = "v1alpha1",
-    shortname = "hydradoompod",
+    shortname = "hydradoomnode",
     category = "hydradoom",
-    plural = "hydradoompods",
+    plural = "hydradoomnodes",
     namespaced
 )]
-#[kube(status = "HydraDoomPodStatus")]
+#[kube(status = "HydraDoomNodeStatus")]
 #[kube(printcolumn = r#"
         {"name": "Local URI", "jsonPath":".status.localUrl", "type": "string"}, 
         {"name": "External URI", "jsonPath": ".status.externalUrl", "type": "string"}
     "#)]
 #[serde(rename_all = "camelCase")]
-pub struct HydraDoomPodSpec {
+pub struct HydraDoomNodeSpec {
     pub image: Option<String>,
     pub open_head_image: Option<String>,
     pub configmap: Option<String>,
@@ -46,27 +46,27 @@ pub struct HydraDoomPodSpec {
 
 #[derive(Deserialize, Serialize, Clone, Default, Debug, JsonSchema)]
 #[serde(rename_all = "camelCase")]
-pub struct HydraDoomPodStatus {
+pub struct HydraDoomNodeStatus {
     pub local_url: String,
     pub external_url: String,
 }
 
-impl HydraDoomPod {
-    pub fn pod_name(&self) -> String {
-        format!("hydra-pod-{}", self.name_any())
+impl HydraDoomNode {
+    pub fn internal_name(&self) -> String {
+        format!("hydra-doom-node-{}", self.name_any())
     }
 
-    pub fn pod_labels(&self) -> BTreeMap<String, String> {
+    pub fn internal_labels(&self) -> BTreeMap<String, String> {
         BTreeMap::from([
-            ("component".to_string(), "hydra-pod".to_string()),
-            ("hydra-pod-id".to_string(), self.name_any()),
+            ("component".to_string(), "hydra-doom-node".to_string()),
+            ("hydra-doom-node-id".to_string(), self.name_any()),
             ("run-on".to_string(), "fargate".to_string()),
         ])
     }
 
     pub fn deployment(&self, config: &Config, constants: &K8sConstants) -> Deployment {
-        let name = self.pod_name();
-        let labels = self.pod_labels();
+        let name = self.internal_name();
+        let labels = self.internal_labels();
         let mut open_head_args = vec![
             "--network-id".to_string(),
             self.spec.network_id.to_string(),
@@ -207,8 +207,8 @@ impl HydraDoomPod {
     }
 
     pub fn service(&self, _config: &Config, constants: &K8sConstants) -> Service {
-        let name = self.pod_name();
-        let labels = self.pod_labels();
+        let name = self.internal_name();
+        let labels = self.internal_labels();
         Service {
             metadata: ObjectMeta {
                 name: Some(name),