feat(validator): Simplify and change output JSON

Simplify/flatten the reply JSON object.

With this patch, the validator will output a JSON object
with mandatory success field set to true and an empty
error list. E.g:
   {
       "success": true,
       "errors": []
   }

If there is an error, success will be false and errors
contain one or more error objects. Each of the error
objects contains a type, a message and, optionally a
subtype.

Type is one of:
   "Environment"
   "Deserialization"
   "Metadata"
   "Conversion"
   "Configuration"

The optional subtype is informational. Currently it is
only set for errors of type Deserialization.

E.g:

   {
     "success": false,
     "errors": [
       {
         "type": "Deserialization",
         "subtype": "Syntax",
         "message": "trailing comma at line 8 column 3"
       }
     ]
   }

Signed-off-by: Fredi Raspall <fredi@githedgehog.com>

Author: Fredi-raspall

Cargo.lock

@@ -12,7 +12,6 @@ path = "src/main.rs"
 [dependencies]
 config = { workspace = true }
 k8s-intf = { workspace = true }
-ordermap = { workspace = true, features = ["serde"] }
 
 serde = { workspace = true }
 serde_json = { workspace = true }

validator/Cargo.toml

@@ -12,27 +12,21 @@
 
 use config::{ExternalConfig, GwConfig};
 use k8s_intf::generated::gateway_agent_crd::GatewayAgent;
-use ordermap::OrderMap;
 use serde::{Deserialize, Serialize};
 use std::io::{self, Read};
 
-#[derive(Serialize, Deserialize, Default)]
+#[derive(Default)]
 struct ConfigErrors {
     errors: Vec<String>, // only one error is supported at the moment
 }
 
-#[derive(Serialize, Deserialize, Default)]
 struct DeserializeError {
     hint: String,
-    line: usize,
-    column: usize,
-    category: String,
-    context: OrderMap<usize, String>,
+    subtype: String,
 }
 
-/// The type representing the outcome of a validation request
-#[derive(Serialize, Deserialize, Default)]
-enum ValidateReply {
+/// The type representing an error when validating a request
+enum ValidateError {
     /// This type contains errors that may occur when using this tool.
     EnvironmentError(String),
 
@@ -55,108 +49,175 @@ enum ValidateReply {
     ///   - contains values that are not allowed / supported
     ///
     /// which would prevent the gateway from functioning correctly.
-    /// Unlike any of the previous, these are errors the user is responsible for.
+    /// Together with some conversion errors, these are errors the user is responsible for.
     Configuration(ConfigErrors),
+}
+impl ValidateError {
+    /// Provide a string indicating the type of error
+    fn get_type(&self) -> &str {
+        match self {
+            ValidateError::EnvironmentError(_) => "Environment",
+            ValidateError::DeserializeError(_) => "Deserialization",
+            ValidateError::MetadataError(_) => "Metadata",
+            ValidateError::ConversionError(_) => "Conversion",
+            ValidateError::Configuration(_) => "Configuration",
+        }
+    }
+    /// Provide a string indicating the subtype of an error
+    fn get_subtype(&self) -> Option<String> {
+        match self {
+            ValidateError::DeserializeError(e) => Some(e.subtype.clone()),
+            _ => None,
+        }
+    }
 
-    /// This type signals that the configuration could be processed and that it is VALID.
-    #[default]
-    Success,
+    /// Provide a list of messages depending on the error type
+    fn get_msg(&self) -> Vec<String> {
+        match self {
+            ValidateError::EnvironmentError(v) => vec![v.clone()],
+            ValidateError::DeserializeError(v) => vec![v.hint.clone()],
+            ValidateError::MetadataError(v) => vec![v.clone()],
+            ValidateError::ConversionError(v) => vec![v.clone()],
+            ValidateError::Configuration(v) => v.errors.to_vec(),
+        }
+    }
 }
 
-/// Deserialize json string as a `GatewayAgent`
-fn deserialize(ga_json: &str) -> Result<GatewayAgent, ValidateReply> {
-    let crd = serde_json::from_str::<GatewayAgent>(ga_json).map_err(|e| {
-        let mut deserr = DeserializeError::default();
-        deserr.hint = e.to_string();
-        deserr.line = e.line();
-        deserr.column = e.column();
-        deserr.category = format!("{:?}", e.classify());
-
-        let mut context = OrderMap::new();
-        let start = e.line() - 5;
-        let end = e.line() + 5;
-        for k in start..end {
-            let line = ga_json.lines().nth(k).unwrap_or("").to_string();
-            context.insert(k, line);
+impl From<&ValidateError> for ValidateReply {
+    fn from(value: &ValidateError) -> Self {
+        let r#type = value.get_type();
+        let subtype = value.get_subtype();
+        let msg = value.get_msg();
+
+        ValidateReply {
+            success: false,
+            errors: msg
+                .iter()
+                .map(|m| ValidateErrorJson {
+                    r#type: r#type.to_owned(),
+                    subtype: subtype.clone(),
+                    message: m.clone(),
+                    context: None,
+                })
+                .collect(),
         }
-        deserr.context = context;
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+struct ValidateErrorJson {
+    r#type: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    subtype: Option<String>,
+    message: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    context: Option<String>,
+}
 
-        ValidateReply::DeserializeError(deserr)
+/// The type representing the outcome of a validation request
+#[derive(Serialize, Deserialize)]
+struct ValidateReply {
+    success: bool,
+    errors: Vec<ValidateErrorJson>,
+}
+impl ValidateReply {
+    fn success() -> Self {
+        Self {
+            success: true,
+            errors: vec![],
+        }
+    }
+}
+
+/// Deserialize JSON string as a `GatewayAgent`
+fn deserialize(ga_json: &str) -> Result<GatewayAgent, ValidateError> {
+    let crd = serde_json::from_str::<GatewayAgent>(ga_json).map_err(|e| {
+        let deserr = DeserializeError {
+            hint: e.to_string(),
+            subtype: format!("{:?}", e.classify()),
+        };
+        ValidateError::DeserializeError(deserr)
     })?;
 
     Ok(crd)
 }
 
 /// Validate metadata
-fn validate_metadata(crd: &GatewayAgent) -> Result<&str, ValidateReply> {
-    let genid = crd.metadata.generation.ok_or(ValidateReply::MetadataError(
+fn validate_metadata(crd: &GatewayAgent) -> Result<&str, ValidateError> {
+    let genid = crd.metadata.generation.ok_or(ValidateError::MetadataError(
         "Missing generation Id".to_string(),
     ))?;
     if genid == 0 {
-        return Err(ValidateReply::MetadataError(
+        return Err(ValidateError::MetadataError(
             "Invalid generation Id".to_string(),
         ));
     }
     let gwname = crd
         .metadata
         .name
         .as_ref()
-        .ok_or(ValidateReply::MetadataError(
+        .ok_or(ValidateError::MetadataError(
             "Missing gateway name".to_string(),
         ))?;
     if gwname.is_empty() {
-        return Err(ValidateReply::MetadataError(
+        return Err(ValidateError::MetadataError(
             "Invalid gateway name".to_string(),
         ));
     }
     let namespace = crd
         .metadata
         .namespace
         .as_ref()
-        .ok_or(ValidateReply::MetadataError(
+        .ok_or(ValidateError::MetadataError(
             "Missing namespace".to_string(),
         ))?;
     if namespace.as_str() != "fab" {
-        return Err(ValidateReply::MetadataError(format!(
+        return Err(ValidateError::MetadataError(format!(
             "Invalid namespace {namespace}"
         )));
     }
 
     Ok(gwname.as_str())
 }
 
-fn validate(gwagent_json: &str) -> Result<ValidateReply, ValidateReply> {
+/// Main validation function
+fn validate(gwagent_json: &str) -> Result<(), ValidateError> {
     let crd = deserialize(gwagent_json)?;
     let gwname = validate_metadata(&crd)?;
 
     let external = ExternalConfig::try_from(&crd)
-        .map_err(|e| ValidateReply::ConversionError(e.to_string()))?;
+        .map_err(|e| ValidateError::ConversionError(e.to_string()))?;
 
     let mut gwconfig = GwConfig::new(gwname, external);
     gwconfig.validate().map_err(|e| {
-        let mut errors = ConfigErrors::default();
-        errors.errors.push(e.to_string());
-        ValidateReply::Configuration(errors)
+        let mut config = ConfigErrors::default();
+        config.errors.push(e.to_string());
+        ValidateError::Configuration(config)
     })?;
 
-    Ok(ValidateReply::Success)
+    Ok(())
 }
 
-fn validate_from_stdin() -> Result<ValidateReply, ValidateReply> {
+/// Read from stdin, deserialize as JSON and validate
+fn validate_from_stdin() -> Result<(), ValidateError> {
     let mut input = String::new();
     io::stdin()
         .read_to_string(&mut input)
-        .map_err(|e| ValidateReply::EnvironmentError(format!("Failed to read from stdin: {e}")))?;
+        .map_err(|e| ValidateError::EnvironmentError(format!("Failed to read from stdin: {e}")))?;
 
     validate(&input)
 }
 
-fn main() {
-    match validate_from_stdin() {
-        Ok(reply) => println!("{}", serde_json::to_string_pretty(&reply).unwrap()),
-        Err(reply) => {
-            let json = serde_json::to_string_pretty(&reply).unwrap();
-            println!("{json}");
-        }
+/// Build a validation reply to be output as JSON
+fn build_reply(result: Result<(), ValidateError>) -> ValidateReply {
+    match result {
+        Ok(()) => ValidateReply::success(),
+        Err(e) => ValidateReply::from(&e),
     }
 }
+
+fn main() {
+    let result = validate_from_stdin();
+    let reply = build_reply(result);
+    println!("{}", serde_json::to_string_pretty(&reply).unwrap());
+}