examples/kube-rs/src/main.rs

@@ -4,13 +4,13 @@ use harmony_macros::yaml;
 use k8s_openapi::{
     api::{
         apps::v1::{Deployment, DeploymentSpec},
-        core::v1::{Container, PodSpec, PodTemplateSpec},
+        core::v1::{Container, Node, Pod, PodSpec, PodTemplateSpec},
     },
     apimachinery::pkg::apis::meta::v1::LabelSelector,
 };
 use kube::{
-    Api, Client, ResourceExt,
+    Api, Client, Config, ResourceExt,
-    api::{ObjectMeta, PostParams},
+    api::{ListParams, ObjectMeta, PostParams},
 };
 
 #[tokio::main]
@@ -42,7 +42,8 @@ async fn main() {
     //     println!("found node {} status {:?}", n.name_any(), n.status.unwrap())
     // }
 
-    assert_eq!(nginx_deployment(), nginx_macro());
+    let nginxdeployment = nginx_deployment_2();
+    let nginxdeployment = nginx_deployment_serde();
     assert_eq!(nginx_deployment_2(), nginx_macro());
     assert_eq!(nginx_deployment_serde(), nginx_macro());
     let nginxdeployment = nginx_macro();
@@ -148,7 +149,6 @@ fn nginx_deployment_2() -> Deployment {
 
     deployment
 }
-
 fn nginx_deployment() -> Deployment {
     let deployment = Deployment {
         metadata: ObjectMeta {

examples/nanodc/src/main.rs

@@ -1,7 +1,10 @@
 use harmony::{
     inventory::Inventory,
     maestro::Maestro,
-    modules::dummy::{ErrorScore, PanicScore, SuccessScore},
+    modules::{
+        dummy::{ErrorScore, PanicScore, SuccessScore},
+        k8s::deployment::K8sDeploymentScore,
+    },
     topology::HAClusterTopology,
 };
 

examples/tui/src/main.rs

@@ -7,6 +7,7 @@ use harmony::{
         dns::DnsScore,
         dummy::{ErrorScore, PanicScore, SuccessScore},
         load_balancer::LoadBalancerScore,
+        okd::load_balancer::OKDLoadBalancerScore,
     },
     topology::{
         BackendServer, HAClusterTopology, HealthCheck, HttpMethod, HttpStatusCode,

harmony/src/domain/interpret/mod.rs

@@ -7,6 +7,7 @@ use super::{
     data::{Id, Version},
     executors::ExecutorError,
     inventory::Inventory,
+    topology::Topology,
 };
 
 pub enum InterpretName {

harmony/src/domain/score.rs

@@ -82,7 +82,7 @@ where
             };
 
             let formatted_val = self.format_value_as_string(v, indent + 1);
-            let lines = formatted_val.lines().map(|line| line.trim_start());
+            let mut lines = formatted_val.lines().map(|line| line.trim_start());
 
             let wrapped_lines: Vec<_> = lines
                 .flat_map(|line| self.wrap_or_truncate(line.trim_start(), 48))

harmony/src/domain/topology/k8s_anywhere.rs

@@ -1,3 +1,5 @@
+use std::io;
+
 use async_trait::async_trait;
 use inquire::Confirm;
 use log::{info, warn};
@@ -14,13 +16,15 @@ use crate::{
 use super::{Topology, k8s::K8sClient};
 
 struct K8sState {
-    _client: K8sClient,
+    client: K8sClient,
-    _source: K8sSource,
+    source: K8sSource,
     message: String,
 }
 
 enum K8sSource {
+    RemoteCluster,
     LocalK3d,
+    // TODO: Add variants for cloud providers like AwsEks, Gke, Aks
 }
 
 pub struct K8sAnywhereTopology {
@@ -58,14 +62,14 @@ impl K8sAnywhereTopology {
 
         if k8s_anywhere_config.use_system_kubeconfig {
             match self.try_load_system_kubeconfig().await {
-                Some(_client) => todo!(),
+                Some(client) => todo!(),
                 None => todo!(),
             }
         }
 
         if let Some(kubeconfig) = k8s_anywhere_config.kubeconfig {
             match self.try_load_kubeconfig(&kubeconfig).await {
-                Some(_client) => todo!(),
+                Some(client) => todo!(),
                 None => todo!(),
             }
         }
@@ -89,8 +93,8 @@ impl K8sAnywhereTopology {
         info!("Starting K8sAnywhere installation");
         match self.try_install_k3d().await {
             Ok(client) => Ok(Some(K8sState {
-                _client: client,
+                client,
-                _source: K8sSource::LocalK3d,
+                source: K8sSource::LocalK3d,
                 message: "Successfully installed K3D cluster and acquired client".to_string(),
             })),
             Err(_) => todo!(),

harmony/src/modules/helm/chart.rs

@@ -8,7 +8,9 @@ use helm_wrapper_rs;
 use helm_wrapper_rs::blocking::{DefaultHelmExecutor, HelmExecutor};
 use non_blank_string_rs::NonBlankString;
 use serde::Serialize;
+use serde::de::DeserializeOwned;
 use std::collections::HashMap;
+use std::path::PathBuf;
 
 #[derive(Debug, Clone, Serialize)]
 pub struct HelmChartScore {

harmony/src/modules/k3d/install.rs

@@ -38,14 +38,14 @@ impl<T: Topology> Score<T> for K3DInstallationScore {
 }
 
 #[derive(Debug)]
-pub struct K3dInstallationInterpret {}
+struct K3dInstallationInterpret {}
 
 #[async_trait]
 impl<T: Topology> Interpret<T> for K3dInstallationInterpret {
     async fn execute(
         &self,
-        _inventory: &Inventory,
+        inventory: &Inventory,
-        _topology: &T,
+        topology: &T,
     ) -> Result<Outcome, InterpretError> {
         todo!()
     }

harmony/src/modules/okd/load_balancer.rs

@@ -13,7 +13,7 @@ use crate::{
 };
 
 impl std::fmt::Display for OKDLoadBalancerScore {
-    fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         todo!()
     }
 }

harmony/src/modules/okd/upgrade.rs

@@ -2,15 +2,15 @@ use crate::data::Version;
 
 #[derive(Debug, Clone)]
 pub struct OKDUpgradeScore {
-    _current_version: Version,
+    current_version: Version,
-    _target_version: Version,
+    target_version: Version,
 }
 
 impl OKDUpgradeScore {
     pub fn new() -> Self {
         Self {
-            _current_version: Version::from("4.17.0-okd-scos.0").unwrap(),
+            current_version: Version::from("4.17.0-okd-scos.0").unwrap(),
-            _target_version: Version::from("").unwrap(),
+            target_version: Version::from("").unwrap(),
         }
     }
 }

harmony/src/modules/opnsense/shell.rs

@@ -27,7 +27,7 @@ pub struct OPNsenseShellCommandScore {
 }
 
 impl Serialize for OPNsenseShellCommandScore {
-    fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {

harmony/src/modules/opnsense/upgrade.rs

@@ -17,7 +17,7 @@ pub struct OPNSenseLaunchUpgrade {
 }
 
 impl Serialize for OPNSenseLaunchUpgrade {
-    fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {