refactor: Big internal refactor

src/cluster.rs

@@ -8,18 +8,19 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use walkdir::WalkDir;
 
-use crate::get_talos_config_path;
-use crate::node::{Node, OptionalNode};
+use crate::environment::PathEnvironment;
+use crate::get_talos_path;
+use crate::node::{Node, OptionalNodeDeserialize};
 use crate::patch::Patches;
 
 #[optional_struct]
 #[derive(Debug, Deserialize, JsonSchema, Clone)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub struct Base {
+pub(crate) struct Base {
     #[serde(default)]
     pub(crate) kernel_args: Vec<String>,
     #[serde(default)]
-    pub(crate) patches: Patches,
+    pub(crate) patches: Patches<String>,
 }
 
 #[optional_struct]
@@ -30,109 +31,125 @@ pub struct Version {
     talos: semver::Version,
 }
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema, Clone, PartialEq, Eq)]
+#[derive(Debug, Serialize, Deserialize, JsonSchema, Clone, Copy, PartialEq, Eq)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub enum ClusterEnv {
     Production,
     Staging,
 }
 
-#[derive(Debug, Serialize, Deserialize, JsonSchema, Clone, PartialEq, Eq)]
-#[serde(untagged)]
-pub enum NodeEntry {
-    Name(String),
-    #[serde(skip_deserializing)]
-    Node(Box<Node>),
-}
-
 #[optional_struct]
-#[derive(Debug, Serialize, Deserialize, JsonSchema, Clone)]
+#[derive(Debug, Deserialize, JsonSchema, Clone)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub struct Cluster {
-    #[serde(skip_deserializing)]
-    name: String,
+struct ClusterDeserialize {
     #[optional_rename(OptionalVersion)]
     #[optional_wrap]
     version: Version,
-    nodes: Vec<NodeEntry>,
+    nodes: Vec<String>,
     cluster_env: ClusterEnv,
     control_plane_ip: Ipv4Addr,
     secrets_file: PathBuf,
-    #[serde(default, skip_serializing)]
+    #[serde(default)]
     #[optional_skip_wrap]
-    pub(crate) default: OptionalNode,
+    default: OptionalNodeDeserialize,
     #[optional_rename(OptionalBase)]
     #[optional_wrap]
-    #[serde(skip_serializing)]
-    pub(crate) base: Base,
-    // pub secrets_file: PathBuf,
+    base: Base,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Cluster {
+    name: String,
+    version: Version,
+    nodes: Vec<Node>,
+    cluster_env: ClusterEnv,
+    control_plane_ip: Ipv4Addr,
+    secrets_file: PathBuf,
 }
 
 impl Cluster {
-    pub fn get(cluster_name: &str, env: &Environment) -> Self {
-        let path = get_talos_config_path()
-            .join("clusters")
-            .join("default.yaml");
+    pub(crate) fn get(cluster_name: &str, env: &Environment) -> Self {
+        let path = get_talos_path().join("clusters").join("default.yaml");
 
-        let default: OptionalCluster = if path.exists() {
+        let default: OptionalClusterDeserialize = if path.exists() {
             let content = std::fs::read_to_string(path).unwrap();
             serde_yaml::from_str(&content).unwrap()
         } else {
             Default::default()
         };
 
-        let mut path = get_talos_config_path().join("clusters").join(cluster_name);
+        let mut path = get_talos_path().join("clusters").join(cluster_name);
         path.add_extension("yaml");
         let content = std::fs::read_to_string(path).unwrap();
 
-        let mut cluster: OptionalCluster = serde_yaml::from_str(&content).unwrap();
-        cluster.name = Some(cluster_name.to_string());
+        let mut cluster: OptionalClusterDeserialize = serde_yaml::from_str(&content).unwrap();
 
         // For some reason apply on the cluster does not properly apply to the default settings...
         // So we manually apply it here first
         cluster.default = default.default.clone().apply(cluster.default);
 
-        let mut cluster: Self = default.apply(cluster).try_into().unwrap();
+        let cluster: ClusterDeserialize = default.apply(cluster).try_into().unwrap();
+        let nodes = cluster.nodes;
+        let default = cluster.default;
+        let base = cluster.base;
 
-        cluster.nodes = cluster
-            .nodes
-            .clone()
-            .into_iter()
-            .map(|node_entry| {
-                if let NodeEntry::Name(name) = node_entry {
-                    NodeEntry::Node(Box::new(Node::get(&name, env, &cluster)))
-                } else {
-                    node_entry
-                }
-            })
-            .collect();
-
-        cluster.secrets_file = get_talos_config_path()
+        let secrets_file = get_talos_path()
             .join("secrets")
             .join(cluster.secrets_file)
             .absolute()
             .unwrap();
 
-        cluster
+        let cluster = Self {
+            name: cluster_name.into(),
+            version: cluster.version,
+            nodes: vec![],
+            cluster_env: cluster.cluster_env,
+            control_plane_ip: cluster.control_plane_ip,
+            secrets_file,
+        };
+
+        let nodes = nodes
+            .iter()
+            .map(|name| Node::get(name, env, &cluster, &default, &base))
+            .collect();
+
+        Self { nodes, ..cluster }
+    }
+
+    pub fn get_all() -> Vec<Cluster> {
+        let env = PathEnvironment::new_patches();
+
+        WalkDir::new(get_talos_path().join("clusters"))
+            .into_iter()
+            .filter_map(|e| e.ok())
+            .filter(|e| e.metadata().unwrap().is_file())
+            .filter_map(|e| {
+                let mut path = PathBuf::from_str(&e.file_name().to_string_lossy()).unwrap();
+                path.set_extension("");
+
+                let name = path.to_string_lossy().to_string();
+
+                if name == "default" {
+                    return None;
+                }
+
+                Some(Cluster::get(&name, &env))
+            })
+            .collect()
+    }
+
+    pub fn nodes(&self) -> &[Node] {
+        &self.nodes
     }
 }
 
-pub fn get_clusters(env: &Environment) -> Vec<Cluster> {
-    WalkDir::new(get_talos_config_path().join("clusters"))
-        .into_iter()
-        .filter_map(|e| e.ok())
-        .filter(|e| e.metadata().unwrap().is_file())
-        .filter_map(|e| {
-            let mut path = PathBuf::from_str(&e.file_name().to_string_lossy()).unwrap();
-            path.set_extension("");
+impl JsonSchema for Cluster {
+    fn schema_name() -> std::borrow::Cow<'static, str> {
+        "Cluster".into()
+    }
 
-            let name = path.to_string_lossy().to_string();
-
-            if name == "default" {
-                return None;
-            }
-
-            Some(Cluster::get(&name, env))
-        })
-        .collect()
+    fn json_schema(generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        OptionalClusterDeserialize::json_schema(generator)
+    }
 }