feat(k8s-less): augment k8s-less to write status to file

Augments the k8s-less client to write status in yaml and json
each time a configuration is successfully applied.

In this implementation, the state is serialized in two files:
  - gwstatus.json
  - gwstatus.yaml

within a "state" directory created in the watched directory.
This is to avoid needing to add another cmd line option for
the directory to store the status files, which seems unnecessary
at this point.

Signed-off-by: Fredi Raspall <[email protected]>

Author: Fredi-raspall

mgmt/src/processor/k8s_less_client.rs

@@ -4,33 +4,62 @@
 use config::{ExternalConfig, GwConfig};
 use futures::TryFutureExt;
 use k8s_less::kubeless_watch_gateway_agent_crd;
+use std::path::PathBuf;
 use std::sync::Arc;
+use tokio::fs::create_dir_all;
 use tracing::{error, info};
 
+use crate::processor::k8s_client::build_gateway_status;
 use crate::processor::mgmt_client::{ConfigClient, ConfigProcessorError};
+use k8s_intf::utils::save;
 
 #[derive(Debug, thiserror::Error)]
 pub enum K8sLessError {
     #[error("K8sless exited early")]
     EarlyTermination,
     #[error("Watching error: {0}")]
     WatchError(String),
+    #[error("Internal error: {0}")]
+    Internal(String),
 }
 
 pub struct K8sLess {
     pathdir: String,
+    statedir: String,
     client: ConfigClient,
 }
 
 impl K8sLess {
     pub fn new(pathdir: &str, client: ConfigClient) -> Self {
         Self {
             pathdir: pathdir.to_string(),
+            statedir: pathdir.to_string() + "/state",
             client,
         }
     }
 
+    async fn update_gateway_status(&self) {
+        let Some(k8s_status) = build_gateway_status(&self.client).await else {
+            return;
+        };
+        let mut state_dir = PathBuf::from(&self.statedir);
+        state_dir.push("gwstatus");
+
+        let state_file = state_dir.to_str().unwrap_or_else(|| unreachable!());
+        if let Err(e) = save(state_file, &k8s_status) {
+            error!("Failed to save state: {e}");
+        }
+    }
+
     pub async fn start_config_watch(k8sless: Arc<Self>) -> Result<(), K8sLessError> {
+        // create directory to store status updates
+        create_dir_all(&k8sless.statedir).await.map_err(|e| {
+            K8sLessError::Internal(format!(
+                "Failed to create directory '{}': {e}",
+                k8sless.statedir
+            ))
+        })?;
+
         info!("Starting config watcher for directory {}", k8sless.pathdir);
 
         kubeless_watch_gateway_agent_crd(&k8sless.pathdir.clone(), async move |ga| {
@@ -55,7 +84,10 @@ impl K8sLess {
 
                     // request the config processor to apply the config and update status on success
                     match k8sless.client.apply_config(gwconfig).await {
-                        Ok(()) => info!("Config for generation {genid} was successfully applied"),
+                        Ok(()) => {
+                            info!("Config for generation {genid} was successfully applied. Updating status...");
+                            k8sless.update_gateway_status().await;
+                        },
                         Err(e) => error!("Failed to apply the config for generation {genid}: {e}"),
                     }
                 }