feat: added custom serialization logic for Resources

crates/configuration/src/shared/node.rs

@@ -118,8 +118,6 @@ impl Serialize for NodeConfig {
             state.serialize_field("bootnodes_addresses", &self.bootnodes_addresses)?;
         }
 
-        state.serialize_field("resources", &self.resources)?;
-
         if self.resources == self.chain_context.default_resources {
             state.skip_field("resources")?;
         } else {

crates/configuration/src/shared/resources.rs

@@ -2,7 +2,7 @@ use std::error::Error;
 
 use lazy_static::lazy_static;
 use regex::Regex;
-use serde::Serialize;
+use serde::{ser::SerializeStruct, Serialize};
 
 use super::{
     errors::{ConversionError, FieldError},
@@ -64,7 +64,7 @@ impl From<u64> for ResourceQuantity {
 }
 
 /// Resources limits used in the context of podman/k8s.
-#[derive(Debug, Default, Clone, PartialEq, Serialize)]
+#[derive(Debug, Default, Clone, PartialEq)]
 pub struct Resources {
     request_memory: Option<ResourceQuantity>,
     request_cpu: Option<ResourceQuantity>,
@@ -72,6 +72,47 @@ pub struct Resources {
     limit_cpu: Option<ResourceQuantity>,
 }
 
+impl Serialize for Resources {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_struct("Resources", 2)?;
+
+        #[derive(Serialize)]
+        struct ResourcesField {
+            memory: Option<ResourceQuantity>,
+            cpu: Option<ResourceQuantity>,
+        }
+
+        if self.request_memory.is_some() || self.request_memory.is_some() {
+            state.serialize_field(
+                "requests",
+                &ResourcesField {
+                    memory: self.request_memory.clone(),
+                    cpu: self.request_cpu.clone(),
+                },
+            )?;
+        } else {
+            state.skip_field("requests")?;
+        }
+
+        if self.limit_memory.is_some() || self.limit_memory.is_some() {
+            state.serialize_field(
+                "limits",
+                &ResourcesField {
+                    memory: self.limit_memory.clone(),
+                    cpu: self.limit_cpu.clone(),
+                },
+            )?;
+        } else {
+            state.skip_field("limits")?;
+        }
+
+        state.end()
+    }
+}
+
 impl Resources {
     /// Memory limit applied to requests.
     pub fn request_memory(&self) -> Option<&ResourceQuantity> {